Enterprise Disposable Email REST Gateway

// Production Node.js / Playwright / Cypress Integration
import axios from 'axios';

const API_KEY = process.env.TEMPMAIL_API_KEY || 'YOUR_API_KEY';
const client = axios.create({
  baseURL: 'https://api.temp-mail.im/v1',
  headers: { 'Authorization': `Bearer ${API_KEY}` }
});

// 1. Create Disposable Inbox
export async function createInbox() {
  const res = await client.post('/mailboxes/new');
  return res.data; // { email: "...", expires_at: "..." }
}

// 2. Poll for OTP Verification Code
export async function waitForOtp(email, timeoutMs = 30000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const res = await client.get(`/mailboxes/${encodeURIComponent(email)}/messages`);
    if (res.data.messages && res.data.messages.length > 0) {
      const latest = res.data.messages[0];
      const match = latest.text_body.match(/\b\d{4,6}\b/);
      if (match) return match[0];
    }
    await new Promise(r => setTimeout(r, 2000));
  }
  throw new Error('Verification OTP timeout');
}

import time
import re
import requests

API_KEY = "YOUR_API_KEY"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
BASE_URL = "https://api.temp-mail.im/v1"

# 1. Provision an ephemeral mailbox
def create_mailbox():
    response = requests.post(f"{BASE_URL}/mailboxes/new", headers=HEADERS)
    response.raise_for_status()
    return response.json()

# 2. Extract verification OTP code
def get_verification_otp(email_address, timeout=30):
    start = time.time()
    while time.time() - start < timeout:
        res = requests.get(f"{BASE_URL}/mailboxes/{email_address}/messages", headers=HEADERS)
        if res.status_code == 200:
            data = res.json()
            messages = data.get("messages", [])
            if messages:
                body = messages[0].get("text_body", "")
                otp = re.search(r'\b\d{4,6}\b', body)
                if otp:
                    return otp.group(0)
        time.sleep(2)
    raise TimeoutError("OTP email did not arrive in time.")

package main

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

type MailboxResponse struct {
	Email     string    `json:"email"`
	ExpiresAt time.Time `json:"expires_at"`
}

func CreateMailbox(apiKey string) (*MailboxResponse, error) {
	req, _ := http.NewRequest("POST", "https://api.temp-mail.im/v1/mailboxes/new", nil)
	req.Header.Set("Authorization", "Bearer "+apiKey)
	
	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var mb MailboxResponse
	if err := json.NewDecoder(resp.Body).Decode(&mb); err != nil {
		return nil, err
	}
	return &mb, nil
}

<?php
class TempMailGateway {
    private $apiKey;
    private $baseUrl = "https://api.temp-mail.im/v1";

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function getMessages($email) {
        $url = $this->baseUrl . "/mailboxes/" . urlencode($email) . "/messages";
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            "Authorization: Bearer " . $this->apiKey,
            "Accept: application/json"
        ]);
        $res = curl_exec($ch);
        curl_close($ch);
        return json_decode($res, true);
    }
}
?>

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;

public class TempMailGateway
{
    private readonly HttpClient _client;

    public TempMailGateway(string apiKey)
    {
        _client = new HttpClient { BaseAddress = new Uri("https://api.temp-mail.im/v1/") };
        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
    }

    public async Task<JsonElement> FetchInboxAsync(string email)
    {
        var response = await _client.GetAsync($"mailboxes/{Uri.EscapeDataString(email)}/messages");
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(json).RootElement;
    }
}