Geliştirici API Entegrasyon Kılavuzu

async function runMailFlow() {
    const api = "https://mail.ugilabs.com/public_api";
    try {
        const responseGen = await fetch(api + "?action=generate");
        const dataGen = await responseGen.json();
        if (!dataGen.success) return;
        const email = dataGen.email;
        
        await new Promise(resolve => setTimeout(resolve, 5000));
        
        const responseInbox = await fetch(api + "?action=inbox&email=" + encodeURIComponent(email));
        const dataInbox = await responseInbox.json();
        
        if (dataInbox.success && dataInbox.messages.length > 0) {
            const verificationCode = dataInbox.messages[0].otp;
            const verificationUrl = dataInbox.messages[0].verification_url;
        }
        
        const deleteToken = dataGen.delete_token;
        const responseDel = await fetch(api + "?action=delete&email=" + encodeURIComponent(email) + "&token=" + encodeURIComponent(deleteToken));
        const dataDel = await responseDel.json();
    } catch (error) {
        console.error(error);
    }
}

import requests
import time

def process_automation():
    url = "https://mail.ugilabs.com/public_api"
    try:
        r_gen = requests.get(url, params={"action": "generate"}).json()
        if not r_gen.get("success"):
            return None
        email = r_gen.get("email")
        delete_token = r_gen.get("delete_token")
        
        time.sleep(5)
        
        r_inbox = requests.get(url, params={"action": "inbox", "email": email}).json()
        if r_inbox.get("success") and len(r_inbox.get("messages", [])) > 0:
            otp = r_inbox["messages"][0].get("otp")
            ver_url = r_inbox["messages"][0].get("verification_url")
            
        r_del = requests.get(url, params={"action": "delete", "email": email, "token": delete_token}).json()
        return r_del
    except Exception as e:
        return None

<?php

function call_api_flow($action, $params = []) {
    $url = "https://mail.ugilabs.com/public_api?action=" . urlencode($action);
    foreach ($params as $k => $v) {
        $url .= "&" . urlencode($k) . "=" . urlencode($v);
    }
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 15);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

$gen = call_api_flow("generate");
if (isset($gen["success"]) && $gen["success"]) {
    $email = $gen["email"];
    $token = $gen["delete_token"];
    sleep(5);
    $inbox = call_api_flow("inbox", ["email" => $email]);
    if (isset($inbox["success"]) && !empty($inbox["messages"])) {
        $otp = $inbox["messages"][0]["otp"];
    }
    $delete = call_api_flow("delete", ["email" => $email, "token" => $token]);
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class MailFlowService
{
    private static readonly HttpClient client = new HttpClient();

    public async Task ExecuteFlowAsync()
    {
        string baseUrl = "https://mail.ugilabs.com/public_api";
        try
        {
            HttpResponseMessage genRes = await client.GetAsync(baseUrl + "?action=generate");
            string genJson = await genRes.Content.ReadAsStringAsync();
            if (genJson.Contains("\"success\":true"))
            {
                string email = ExtractJsonValue(genJson, "email");
                string token = ExtractJsonValue(genJson, "delete_token");
                await Task.Delay(5000);
                
                HttpResponseMessage inboxRes = await client.GetAsync(baseUrl + "?action=inbox&email=" + email);
                string inboxJson = await inboxRes.Content.ReadAsStringAsync();
                
                HttpResponseMessage delRes = await client.GetAsync(baseUrl + "?action=delete&email=" + email + "&token=" + token);
                string delJson = await delRes.Content.ReadAsStringAsync();
            }
        }
        catch (Exception)
        {
        }
    }

    private string ExtractJsonValue(string json, string key)
    {
        string pattern = "\"" + key + "\":\"";
        int start = json.IndexOf(pattern);
        if (start == -1) return string.Empty;
        start += pattern.Length;
        int end = json.IndexOf("\"", start);
        return json.Substring(start, end - start);
    }
}

package main

import (
	"encoding/json"
	"net/http"
	"net/url"
	"time"
)

type GenResponse struct {
	Success     bool   `json:"success"`
	Email       string `json:"email"`
	DeleteToken string `json:"delete_token"`
}

func runFlow() {
	client := &http.Client{Timeout: 10 * time.Second}
	api := "https://mail.ugilabs.com/public_api"
	
	rGen, err := client.Get(api + "?action=generate")
	if err != nil {
		return
	}
	defer rGen.Body.Close()
	
	var genRes GenResponse
	json.NewDecoder(rGen.Body).Decode(&genRes)
	
	if genRes.Success {
		time.Sleep(5 * time.Second)
		
		rInbox, _ := client.Get(api + "?action=inbox&email=" + url.QueryEscape(genRes.Email))
		rInbox.Body.Close()
		
		rDel, _ := client.Get(api + "?action=delete&email=" + url.QueryEscape(genRes.Email) + "&token=" + url.QueryEscape(genRes.DeleteToken))
		rDel.Body.Close()
	}
}