TempMailg API-Dokumentation

Verwenden Sie diese Dokumentation, um Ihren persönlichen API-Schlüssel zu generieren, den dedizierten Benutzer-API-Host zu verbinden, Postfachnachrichten zu lesen, eigene Postfächer zu verwalten und Temp Mail in Ihre eigenen Apps oder Automatisierungen zu integrieren.

Benutzer-API-Basis-URL

Anforderungsformat Verwenden Sie Ihren API-Schlüssel nur im Authorization Bearer Header und halten Sie die Endpunkt-URLs sauber.

Anmelden, um API-Schlüssel zu erstellen Konto erstellen

Kurze Einrichtungs-Checkliste

Öffnen Sie die API-Verwaltungsseite Ihres Dashboards und erstellen Sie Ihren persönlichen API-Schlüssel.
Kopieren Sie die dort angezeigte genaue Benutzer-API-Basis-URL, zum Beispiel https://v1.yourdomain.com/api.
Senden Sie jede Anfrage an diesen API-Host mit Authorization: Bearer YOUR_USER_API_KEY und Accept: application/json.
Verfolgen Sie Ihr monatliches Anfragekontingent über dieselbe Dashboard-Seite und über die Quota-Header, die bei jeder Benutzer-API-Antwort zurückgegeben werden. Nur erfolgreiche 2xx-Anfragen zählen zum Kontingent.

Wenn die API 404 zurückgibt Stellen Sie sicher, dass Sie den dedizierten Benutzer-API-Host genau so aufrufen, wie auf Ihrer API-Management-Seite gezeigt.

API-Schlüsselzugriff

Melden Sie sich an, um Ihren persönlichen API-Schlüssel zu erstellen und Live-Kontingentdetails anzuzeigen.

Anmelden Anmelden

Authentifizierungsablauf

Generieren Sie Ihren persönlichen API-Schlüssel auf der Dashboard API-Management-Seite.
Senden Sie den Schlüssel als Bearer-Token in jeder Anfrage.
Verwenden Sie die dedizierte Benutzer-API-Basis-URL, die auf Ihrer API-Management-Seite angezeigt wird.
Generieren Sie den Schlüssel jederzeit neu, wenn Sie den alten Schlüssel für ungültig erklären und sofort einen neuen Schlüssel verwenden möchten.

Schlüsselsichtbarkeit Ihr Benutzer-API-Schlüssel bleibt auf Ihrer API-Management-Seite sichtbar, bis Sie ihn neu generieren oder widerrufen.

Erforderliche Header

Authorization: Bearer YOUR_USER_API_KEY
Accept: application/json

Quota-Header, die bei jeder Antwort zurückgegeben werden

Diese Quota-Werte erhöhen sich nur nach erfolgreichen 2xx-Antworten.

X-RateLimit-Limit: 50000
X-RateLimit-Used: 124
X-RateLimit-Remaining: 49876
X-RateLimit-Reset: 2026-05-01T00:00:00+05:00

Benutzer-API-Endpunkte

Jeder Endpunkt unten verwendet dieselbe Basis-URL und dasselbe Bearer-Token. Postfach-, Nachrichten- und Anhangsanfragen werden gegen das authentifizierte Benutzerkonto geprüft.

GET https://v1.tempmailg.com/api/domains?type={type}

Holen Sie die für den aktuellen Benutzerplan und das Konto zugelassenen Domänen ab.

Zulässige Typwerte: free, basic, pro, premium, custom, ultimate, all. Free plan can query free. Paid plans (including any custom plans created in admin panel) can query their plan tag, custom domains, or all.

Erhalten Sie zugelassene Domänen

const response = await fetch('https://v1.tempmailg.com/api/domains?type=free', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.get('https://v1.tempmailg.com/api/domains?type=free', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/domains?type=free');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request GET \
  --url 'https://v1.tempmailg.com/api/domains?type=free' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "requested_type": "free",
        "plan": "pro",
        "plan_name": "Pro Plan",
        "allowed_types": [
            "free",
            "basic",
            "pro",
            "premium",
            "custom",
            "ultimate",
            "all"
        ],
        "domains": [
            {
                "domain": "example.com",
                "type": "Free",
                "custom": false
            }
        ]
    }
}

POST https://v1.tempmailg.com/api/emails

Create a new random or custom mailbox owned by the authenticated user.

Optional body parameters: username (custom username if allowed by plan), domain (allowed domain, e.g. example.com), lifetime (allowed values: 10m, 1h, 2h, 1d, 1w, 1m, unlimited), provider (standard, gmail_alias, outlook_alias).

Create mailbox

const response = await fetch('https://v1.tempmailg.com/api/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.post('https://v1.tempmailg.com/api/emails', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/emails');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request POST \
  --url 'https://v1.tempmailg.com/api/emails' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "id": 2301,
        "email": "customuser@example.com",
        "domain": "example.com",
        "provider": "standard",
        "expire_at": "2026-09-19T10:13:00+00:00",
        "expires_in_seconds": 86400,
        "created_at": "2026-09-18T10:13:00+00:00",
        "email_token": "encrypted-email-token"
    }
}

POST https://v1.tempmailg.com/api/emails/{email}/{username}/{domain}

Aktualisieren oder umschalten Sie ein vorhandenes eigenes Postfach auf einen neuen Benutzernamen und eine zugelassene Domäne.

Verwenden Sie eine vorhandene eigene Postfach-E-Mail in {email}. Optional body parameter: lifetime (allowed values: 10m, 1h, 2h, 1d, 1w, 1m, unlimited).

Eigenes Postfach aktualisieren

const response = await fetch('https://v1.tempmailg.com/api/emails/current@example.com/demo123/example.com', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.post('https://v1.tempmailg.com/api/emails/current@example.com/demo123/example.com', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/emails/current@example.com/demo123/example.com');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request POST \
  --url 'https://v1.tempmailg.com/api/emails/current@example.com/demo123/example.com' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "id": 2302,
        "email": "demo123@example.com",
        "domain": "example.com",
        "expire_at": "2026-09-18T10:23:00+00:00",
        "expires_in_seconds": 600,
        "created_at": "2026-09-18T10:13:00+00:00",
        "email_token": "encrypted-email-token"
    }
}

DELETE https://v1.tempmailg.com/api/emails/{email}

Löschen eines eigenen Postfachs.

Eigenes Postfach löschen

const response = await fetch('https://v1.tempmailg.com/api/emails/demo123@example.com', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.delete('https://v1.tempmailg.com/api/emails/demo123@example.com', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/emails/demo123@example.com');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request DELETE \
  --url 'https://v1.tempmailg.com/api/emails/demo123@example.com' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "message": "Email has been successfully deleted."
}

POST https://v1.tempmailg.com/api/gmail-alias/emails

Create a new Gmail alias temporary mailbox owned by the authenticated user.

Requires the Gmail Alias API permission to be enabled on your subscription plan or unlocked via an API Credit package. Optional parameters: mode (auto, dot, plus, plus_word), username (custom alias username), domain (e.g. gmail.com, googlemail.com), lifetime (allowed values: 10m, 1h, 2h, 1d, 1w, 1m, unlimited).

Create Gmail alias mailbox

const response = await fetch('https://v1.tempmailg.com/api/gmail-alias/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.post('https://v1.tempmailg.com/api/gmail-alias/emails', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/gmail-alias/emails');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request POST \
  --url 'https://v1.tempmailg.com/api/gmail-alias/emails' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "id": 2305,
        "email": "myname.alias123@gmail.com",
        "domain": "gmail.com",
        "provider": "gmail_alias",
        "expire_at": "2026-09-18T11:13:00+00:00",
        "expires_in_seconds": 3600,
        "created_at": "2026-09-18T10:13:00+00:00",
        "email_token": "encrypted-email-token"
    }
}

GET https://v1.tempmailg.com/api/outlook-alias/domains

Fetch active Outlook / Hotmail alias domains available for mailbox generation.

Requires the Outlook Alias API permission to be enabled on your subscription plan or unlocked via an API Credit package. Indicates whether specific domain selection is unlocked on your plan.

Get Outlook alias domains

const response = await fetch('https://v1.tempmailg.com/api/outlook-alias/domains', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.get('https://v1.tempmailg.com/api/outlook-alias/domains', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/outlook-alias/domains');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request GET \
  --url 'https://v1.tempmailg.com/api/outlook-alias/domains' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "domains": [
            {
                "domain": "outlook.com",
                "type": "Outlook/Hotmail",
                "selectable": true,
                "locked": false,
                "disabled_reason": null
            },
            {
                "domain": "hotmail.com",
                "type": "Outlook/Hotmail",
                "selectable": true,
                "locked": false,
                "disabled_reason": null
            }
        ]
    }
}

POST https://v1.tempmailg.com/api/outlook-alias/emails

Create a new Outlook / Hotmail alias temporary mailbox owned by the authenticated user.

Requires the Outlook Alias API permission to be enabled on your subscription plan or unlocked via an API Credit package. Optional parameters: domain (e.g. outlook.com, hotmail.com), username (custom alias username), lifetime (allowed values: 10m, 1h, 2h, 1d, 1w, 1m, unlimited).

Create Outlook alias mailbox

const response = await fetch('https://v1.tempmailg.com/api/outlook-alias/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.post('https://v1.tempmailg.com/api/outlook-alias/emails', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/outlook-alias/emails');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request POST \
  --url 'https://v1.tempmailg.com/api/outlook-alias/emails' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "id": 2306,
        "email": "fastuser_alias45@outlook.com",
        "domain": "outlook.com",
        "provider": "outlook_alias",
        "expire_at": "2026-09-18T11:13:00+00:00",
        "expires_in_seconds": 3600,
        "created_at": "2026-09-18T10:13:00+00:00",
        "email_token": "encrypted-email-token"
    }
}

GET https://v1.tempmailg.com/api/messages?email={email}

Listen Sie Nachrichten für ein eigenes Postfach auf.

Der E-Mail-Abfrageparameter muss dem Konto des authentifizierten Benutzers gehören.

Postfachnachrichten lesen

const response = await fetch('https://v1.tempmailg.com/api/messages?email=demo123@example.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.get('https://v1.tempmailg.com/api/messages?email=demo123@example.com', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/messages?email=demo123@example.com');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request GET \
  --url 'https://v1.tempmailg.com/api/messages?email=demo123@example.com' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "mailbox": "randombox@example.com",
    "messages": [
        {
            "is_seen": false,
            "subject": "Welcome to Temp Mail",
            "from": "Example Sender",
            "from_email": "hello@example.org",
            "to": "randombox@example.com",
            "receivedAt": "2026-09-18 10:13:00",
            "id": "ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1",
            "html": true,
            "content": "<p>Hello from the inbox.</p>",
            "attachments": [
                {
                    "name": "file.txt",
                    "extension": "txt",
                    "size": 91,
                    "url": "https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt"
                }
            ]
        }
    ]
}

GET https://v1.tempmailg.com/api/messages/{messageId}

Lesen Sie eine einzelne eigene Nachricht.

Lesen Sie eine Nachricht

const response = await fetch('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.get('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request GET \
  --url 'https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "data": {
        "is_seen": true,
        "subject": "Welcome to Temp Mail",
        "from": "Example Sender",
        "from_email": "hello@example.org",
        "to": "randombox@example.com",
        "receivedAt": "2026-09-18 10:13:00",
        "id": "ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1",
        "html": true,
        "content": "<p>Hello from the inbox.</p>",
        "attachments": [
            {
                "name": "file.txt",
                "extension": "txt",
                "size": 91,
                "url": "https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt"
            }
        ]
    }
}

DELETE https://v1.tempmailg.com/api/messages/{messageId}

Löschen Sie eine einzelne eigene Nachricht.

Eine Nachricht löschen

const response = await fetch('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.delete('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1', headers=headers, timeout=30)
response.raise_for_status()

print(response.json())

<?php

$ch = curl_init('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($ch);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

var_dump($statusCode, json_decode($response, true));

curl --request DELETE \
  --url 'https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY'

Beispielantwort

{
    "status": true,
    "message": "Message was deleted successfully."
}

GET https://v1.tempmailg.com/api/messages/{messageId}/attachments/{filename}

Einen Anhang von einer eigenen Nachricht herunterladen.

Dieser Endpunkt lädt die Datei direkt herunter.

Einen Anhang herunterladen

const response = await fetch('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
  },
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const blob = await response.blob();
const downloadUrl = window.URL.createObjectURL(blob);
const link = document.createElement('a');
link.href = downloadUrl;
link.download = 'file.txt';
document.body.appendChild(link);
link.click();
link.remove();
window.URL.revokeObjectURL(downloadUrl);

import requests

headers = {
    'Authorization': 'Bearer YOUR_USER_API_KEY',
    'Accept': 'application/json',
}

response = requests.get('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt', headers=headers, stream=True, timeout=30)
response.raise_for_status()

with open('file.txt', 'wb') as handle:
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            handle.write(chunk)

<?php

$fileHandle = fopen('file.txt', 'w');
$ch = curl_init('https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt');

curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_FILE => $fileHandle,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_USER_API_KEY',
        'Accept: application/json',
    ],
]);

if (curl_exec($ch) === false) {
    fclose($fileHandle);
    throw new RuntimeException(curl_error($ch));
}

curl_close($ch);
fclose($fileHandle);

curl --request GET \
  --url 'https://v1.tempmailg.com/api/messages/ap94AWDg123ELQz07vrVB9dLXlbqZM5NGwYxOJKko8n6m1/attachments/file.txt' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_USER_API_KEY' \
  --output file.txt

Download-Verhalten Dieser Endpunkt gibt die angeforderte Datei direkt zurück, anstatt eines JSON-Bodys.

E-Mail-Postfach-Webhooks (Echtzeit-Push)

Statt die REST-API (GET /messages) wiederholt abzufragen, um auf eingehende E-Mails zu prüfen, konfigurieren Sie Webhooks, um neue Nachrichten in Echtzeit an Ihren Server oder Ihre Automatisierungsworkflows zu senden.

Anmelden, um Webhooks einzurichten

Protokoll HTTPS POST

Nutzlastformat JSON

Sicherheit HMAC-SHA256

Verfügbarkeit Premium-Plan

Unterstützte Webhook-Ereignisse

Jeder Webhook kann sich auf eine oder mehrere Ereignistypen abonnieren. Ihre Endpoint erhält eine Ereignismeldung, sobald einer dieser Auslöser aktiviert wird.

email.received Neue E-Mail erhalten

Dispatched in real time whenever a new message reaches the selected mailbox.

mailbox.expired Mailbox Expired

Dispatched when the temporary mailbox expires and webhook processing is paused.

mailbox.reactivated Mailbox Reactivated

Dispatched when an expired mailbox becomes active again under plan rules.

mailbox.deleted Mailbox Deleted

Dispatched right before the webhook and its mailbox are deleted.

Anfragenköpfe & HMAC-Signaturprüfung

Jede Webhook-Lieferung enthält spezielle Sicherheitsheader. Verwenden Sie den X-TempMailg-Signature-Header, um zu überprüfen, dass eingehende Anfragen tatsächlich von TempMailg verschickt wurden und nicht manipuliert wurden.

Überschrift	Beispielwert	Beschreibung
`User-Agent`	TempMailg-Webhooks/1.0	Standard identifier for the webhook delivery worker.
`X-TempMailg-Event`	email.received	The type of event that triggered this delivery.
`X-TempMailg-Event-Id`	e7b1a2c3-4d5e-6f7a-8b9c-0d1e2f3a4b5c	Unique UUID assigned to this delivery attempt.
`X-TempMailg-Timestamp`	1725192000	Unix epoch timestamp indicating when the request was initiated.
`X-TempMailg-Signature`	sha256=d7a8fbb307d7809469ca933b02d82941...	HMAC-SHA256 signature calculated from {timestamp}.{raw_body} using your secret.
`X-TempMailg-Test`	false	True when dispatched by the "Send Test Ping" feature in your dashboard.

Wie die Signaturprüfung funktioniert

Die Signatur wird mit HMAC und SHA256 über den folgenden String berechnet: hash_hmac('sha256', "${X-TempMailg-Timestamp}.${raw_request_body}", your_webhook_secret)

Verwenden Sie immer die Rohdaten des Anforderungskörpers Ihrer Endpunktes zur Überprüfung der Signaturen, bevor Sie JSON parsen.

Beispiel-Ereignisdaten (email.received)

Wird als application/json im HTTP POST-Anfragekörper übermittelt.

{
    "id": "e7b1a2c3-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    "version": "1.0",
    "event": "email.received",
    "occurred_at": "2026-09-18T10:13:00+00:00",
    "test": false,
    "mailbox": {
        "id": 1024,
        "email": "developer@v1.tempmailg.com"
    },
    "data": {
        "message_id": "7a8b9c0d1e2f",
        "subject": "Your Verification Code: 948201",
        "from": "auth@service.com",
        "to": "developer@v1.tempmailg.com",
        "date": "2026-09-18T10:13:00+00:00",
        "attachments_count": 0,
        "text_preview": "Hello, your one-time verification code is 948201. It will expire in 10 minutes.",
        "email_url": "https://tempmailg.com/mailbox/1024?message=7a8b9c0d1e2f",
        "inbox_url": "https://tempmailg.com/mailbox/1024"
    }
}

Beispielcode für Webhook-Empfänger

Vorbereitete Code-Snippets, die zeigen, wie Sie HMAC-SHA256-Signaturen empfangen, verifizieren und Webhook-Ereignisse in Ihrer Backend-Dienstleistung verarbeiten können.

Empfänger-Implementierung

const express = require('express');
const crypto = require('crypto');

const app = express();
const WEBHOOK_SECRET = 'your_webhook_signing_secret';

// Capture raw body buffer for HMAC-SHA256 signature verification
app.use(express.json({
  verify: (req, res, buf) => {
    req.rawBody = buf.toString('utf8');
  }
}));

app.post('/webhook', (req, res) => {
  const timestamp = req.headers['x-tempmailg-timestamp'];
  const signatureHeader = req.headers['x-tempmailg-signature'] || '';

  // Calculate HMAC-SHA256 signature
  const expectedSignature = 'sha256=' + crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(`${timestamp}.${req.rawBody}`)
    .digest('hex');

  // Verify signature
  if (signatureHeader !== expectedSignature) {
    return res.status(401).json({ error: 'Invalid webhook signature' });
  }

  const { event, mailbox, data } = req.body;
  console.log(`[Event: ${event}] Mailbox: ${mailbox.email}`);

  if (event === 'email.received') {
    console.log(`From: ${data.from}`);
    console.log(`Subject: ${data.subject}`);
    console.log(`Preview: ${data.text_preview}`);
  }

  // Acknowledge receipt with HTTP 200
  res.status(200).json({ received: true });
});

app.listen(3000, () => console.log('Webhook receiver running on port 3000'));

from flask import Flask, request, jsonify
import hmac
import hashlib

app = Flask(__name__)
WEBHOOK_SECRET = b"your_webhook_signing_secret"

@app.route("/webhook", methods=["POST"])
def handle_webhook():
    timestamp = request.headers.get("X-TempMailg-Timestamp", "")
    signature_header = request.headers.get("X-TempMailg-Signature", "")

    # Calculate expected HMAC-SHA256 signature
    raw_body = request.get_data()
    signed_payload = f"{timestamp}.".encode("utf-8") + raw_body
    expected_signature = "sha256=" + hmac.new(
        WEBHOOK_SECRET, signed_payload, hashlib.sha256
    ).hexdigest()

    # Verify signature securely
    if not hmac.compare_digest(signature_header, expected_signature):
        return jsonify({"error": "Invalid signature"}), 401

    payload = request.get_json()
    event = payload.get("event")
    mailbox = payload.get("mailbox", {}).get("email")
    data = payload.get("data", {})

    print(f"[{event}] Mailbox: {mailbox}")
    if event == "email.received":
        print(f"From: {data.get('from')}")
        print(f"Subject: {data.get('subject')}")
        print(f"Preview: {data.get('text_preview')}")

    # Return 200 OK to acknowledge receipt
    return jsonify({"received": True}), 200

if __name__ == "__main__":
    app.run(port=5000)

<?php

$secret = 'your_webhook_signing_secret';
$rawBody = file_get_contents('php://input');
$timestamp = $_SERVER['HTTP_X_TEMPMAILG_TIMESTAMP'] ?? '';
$receivedSignature = $_SERVER['HTTP_X_TEMPMAILG_SIGNATURE'] ?? '';

// Calculate HMAC-SHA256 signature
$expectedSignature = 'sha256=' . hash_hmac('sha256', $timestamp . '.' . $rawBody, $secret);

// Verify signature
if (!hash_equals($expectedSignature, $receivedSignature)) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid signature']);
    exit;
}

$payload = json_decode($rawBody, true);
$event = $payload['event'] ?? '';
$mailbox = $payload['mailbox']['email'] ?? '';
$data = $payload['data'] ?? [];

if ($event === 'email.received') {
    $sender = $data['from'] ?? '';
    $subject = $data['subject'] ?? '';
    $preview = $data['text_preview'] ?? '';
    // Process new incoming email...
}

// Acknowledge receipt
http_response_code(200);
echo json_encode(['received' => true]);

Lieferung & Wiederholungsrichtlinie

Erwarteter Statuscode: Ihre Endpoint muss einen HTTP-Statuscode im Bereich 2xx (z. B. 200 OK) zurückgeben, um die Zustellung zu bestätigen.
Zeitüberschreitung (Request Timeout): Webhook-Anfragen timeout nach 10 Sekunden. Geben Sie sofort einen 200 OK zurück und verarbeiten Sie langlaufende Aufgaben asynchron.
Automatische Wiederholungsversuche: Falls der Server mit 408, 429 oder 5xx antwortet, wird die Lieferung bis zu 10 Mal mit exponentieller Rücksetzung wiederholt.
Sicherung (Autopause): Automatische Pause des Webhooks bei anhaltenden Lieferfehlern, um beide Systeme zu schützen.

Unterstützte Integrationen

Sie können TempMailg-Webhooks direkt an Ihre bevorzugten Entwicklertools und Chat-Apps ohne Code weiterleiten:

Custom HTTP POST / JSON Discord Slack Mattermost Microsoft Teams Google Chat Zapier Make.com Pipedream n8n much more

Anmelden, um Webhooks zu konfigurieren

Häufige Fehler und Fehlerbehebung

Dies sind die häufigsten Antwortcodes, die Ihnen bei der Integration der Benutzer-API begegnen können.

401 Unauthorized

Ungültiges oder fehlendes Bearer-Token.

403 Forbidden

Der Benutzer-API-Zugriff ist für den aktuellen Benutzerplan deaktiviert.

404 Not Found

Die Ressource wurde auf dem erlaubten Host nicht gefunden oder gehört nicht dem Benutzer.

410 Gone / Expired

Postfach abgelaufen oder inaktiv.

422 Validation Error

Validierung fehlgeschlagen oder das angeforderte Postfach/die Domain ist nicht erlaubt.

429 Rate Limited

Das monatliche Benutzer-API-Kontingent wurde überschritten.

Schnelle Checkliste

401 Unauthorized - Bearer-Token fehlt, ist falsch, wurde widerrufen oder falsch kopiert.
403 Forbidden - Aktueller Plan hat derzeit keinen Benutzer-API-Zugriff.
404 Not Found - Ressource nicht gefunden oder ungültiger Parameter
410 Gone / Expired - Mailbox abgelaufen oder nicht mehr aktiv.
429 Rate Limited - Monatliches Kreditlimit erreicht — kaufen Sie Kredit oder warten Sie auf das Zurücksetzen

Empfohlener nächster Schritt

Wenn Sie angemeldet sind, öffnen Sie zuerst die API-Verwaltung und bestätigen Sie Ihren Schlüssel, Ihr Kontingent, Ihren Planzugriffsstatus und die genaue User API Base URL, bevor Sie Ihre externe App debuggen.

Anmelden, um API-Schlüssel zu konfigurieren