TempMailg Documentação da API

Use esta documentação para gerar sua chave de API pessoal, conectar o host de API de usuário dedicado, ler mensagens da caixa de correio, gerenciar caixas de correio de propriedade e integrar o TempMail aos seus próprios aplicativos ou automações.

URL Base da API do Usuário

Formato da solicitação Use sua chave de API apenas no cabeçalho de autorização Bearer e mantenha as URLs de endpoint limpas.

Faça login para criar chave de API Criar Conta

Lista de verificação de configuração rápida

Abra a página de gerenciamento de API do seu painel e crie sua chave de API pessoal.
Copie a URL Base da API do Usuário exata mostrada lá, por exemplo https://v1.yourdomain.com/api.
Envie cada solicitação para esse host de API com Authorization: Bearer YOUR_USER_API_KEY e Accept: application/json.
Acompanhe sua cota de solicitações mensais na mesma página do painel e nos cabeçalhos de cota retornados em cada resposta de API do usuário. Apenas solicitações bem-sucedidas 2xx contam para a cota.

Se a API retornar 404 Certifique-se de que você está chamando o host dedicado da API do usuário exatamente como mostrado na sua página de Gerenciamento de API.

Acesso à chave da API

Faça login para criar sua chave de API pessoal e visualizar detalhes de cota ao vivo.

Fazer Login Inscreva-se

Fluxo de autenticação

Gere sua chave de API pessoal na página de Gerenciamento de API do painel.
Envie a chave como um token Bearer em cada solicitação.
Use a URL Base dedicada da API do usuário mostrada na sua página de Gerenciamento de API.
Regenere a chave sempre que você quiser invalidar a antiga e começar a usar uma nova chave imediatamente.

Visibilidade da chave Sua chave de API do usuário permanece visível dentro da sua página de Gerenciamento de API até que você a regenere ou revogue.

Cabeçalhos necessários

Authorization: Bearer YOUR_USER_API_KEY
Accept: application/json

Cabeçalhos de cota retornados em cada resposta

Esses valores de cota aumentam apenas após respostas 2xx bem-sucedidas.

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

Pontos de extremidade da API do usuário

Cada ponto de extremidade abaixo usa a mesma URL base e o mesmo token Bearer. Solicitações de caixa de correio, mensagem e anexo são verificadas contra a conta de usuário autenticada.

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

Obter os domínios permitidos para o plano e conta do usuário atual.

Valores de tipo permitidos: 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.

Obter domínios permitidos

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'

Exemplo de resposta

{
    "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'

Exemplo de resposta

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

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

Atualizar ou alternar uma caixa de correio existente de propriedade para um novo nome de usuário e domínio permitido.

Usar um endereço de e-mail existente de propriedade em {email}. Optional body parameter: lifetime (allowed values: 10m, 1h, 2h, 1d, 1w, 1m, unlimited).

Atualizar caixa de correio de propriedade

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'

Exemplo de resposta

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

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

Exclua uma caixa de correio de propriedade.

Excluir caixa de correio de propriedade

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'

Exemplo de resposta

{
    "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'

Exemplo de resposta

{
    "status": true,
    "data": {
        "id": 2305,
        "email": "myname.alias123@gmail.com",
        "domain": "gmail.com",
        "provider": "gmail_alias",
        "expire_at": "2026-09-18T11:13:43+00:00",
        "expires_in_seconds": 3600,
        "created_at": "2026-09-18T10:13:43+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'

Exemplo de resposta

{
    "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'

Exemplo de resposta

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

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

Listar mensagens para uma caixa de correio de propriedade.

O parâmetro de consulta de e-mail deve pertencer à conta do usuário autenticado.

Ler mensagens da caixa de correio

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'

Exemplo de resposta

{
    "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:43",
            "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}

Ler uma mensagem de propriedade única.

Ler uma mensagem

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'

Exemplo de resposta

{
    "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:43",
        "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}

Excluir uma mensagem de propriedade única.

Excluir uma mensagem

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'

Exemplo de resposta

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

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

Baixar um anexo de uma mensagem de propriedade.

Este endpoint baixa o arquivo diretamente.

Baixar um anexo

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

Comportamento de download Este ponto de extremidade retorna o arquivo solicitado diretamente em vez de um corpo JSON.

Webhooks de Caixa Postal (Empurrar em Tempo Real)

Em vez de verificar repetidamente a API REST (GET /messages) para verificar se há e-mails entrantes, configure Webhooks para enviar novas mensagens para seu servidor ou fluxo de trabalho de automação em tempo real.

Faça login para configurar Webhooks

Protocolo HTTPS POST

Formato de Payload JSON

Segurança HMAC-SHA256

Disponibilidade Plano Premium

Eventos de Webhook Suportados

Cada webhook pode se inscrever em um ou mais tipos de eventos. Seu endpoint recebe uma notificação de evento sempre que um desses gatilhos for acionado.

email.received Novo E-mail Recebido

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.

Cabeçalhos de Requisição & Verificação de Assinatura HMAC

Toda entrega de webhook contém cabeçalhos de segurança especiais. Use o cabeçalho X-TempMailg-Signature para verificar que as solicitações entrantes foram realmente enviadas pelo TempMailg e não foram alteradas.

Nome do Cabeçalho	Valor de Exemplo	Descrição
`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.

Como Funciona a Verificação de Assinatura

A assinatura é calculada usando HMAC com SHA256 sobre a string: hash_hmac('sha256', "${X-TempMailg-Timestamp}.${raw_request_body}", your_webhook_secret)

Sempre utilize os bytes brutos do corpo da solicitação do endpoint ao verificar assinaturas antes de analisar o JSON.

Payload de Evento de Exemplo (email.received)

Enviado como application/json no corpo da solicitação HTTP POST.

{
    "id": "e7b1a2c3-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
    "version": "1.0",
    "event": "email.received",
    "occurred_at": "2026-09-18T10:13:43+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:43+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"
    }
}

Exemplos de Código do Receptor de Webhook

Trechos de código prontos para uso que mostram como receber, verificar assinaturas HMAC-SHA256 e processar eventos de webhook no seu serviço de backend.

Implementação do Receptor

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]);

Política de Entrega & Tentativas

Código de Status Esperado: Seu endpoint deve retornar um código de status HTTP 2xx (por exemplo, 200 OK) para confirmar a entrega.
Tempo limite excedido: As requisições de webhook são interrompidas após 10 segundos. Retorne um código 200 OK imediatamente e processe as tarefas longas de forma assíncrona.
Reinícios Automáticos: Se o servidor responder com 408, 429 ou 5xx, a entrega é reintentada até 10 vezes com atraso exponencial.
Disjuntor (Pausa Automática): Falhas consecutivas na entrega contínua pausam automaticamente o webhook para proteger ambos os sistemas.

Integrações Suportadas

Você pode rotear webhooks do TempMailg diretamente para suas ferramentas e aplicativos de desenvolvimento favoritos sem precisar de código:

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

Faça Login para Configurar Webhooks

Erros comuns e solução de problemas

Estes são os códigos de resposta mais comuns que você pode ver ao integrar a API do usuário.

401 Unauthorized

Token Bearer inválido ou ausente.

403 Forbidden

O acesso à API do usuário está desabilitado para o plano de usuário atual.

404 Not Found

O recurso não foi encontrado no host permitido ou não pertence ao usuário.

410 Gone / Expired

Caixa de correio expirou ou está inativa.

422 Validation Error

A validação falhou ou a caixa de correio/solicitação de domínio não é permitida.

429 Rate Limited

A cota de API do usuário mensal foi excedida.

Lista de verificação rápida

401 Unauthorized - O token Bearer está faltando, errado, revogado ou copiado incorretamente.
403 Forbidden - O plano atual não tem acesso à API do usuário no momento.
404 Not Found - Recurso não encontrado ou parâmetro inválido
410 Gone / Expired - Caixa de correio expirou ou não está mais ativa.
429 Rate Limited - Limite de crédito mensal atingido — compre créditos ou aguarde o reinício

Próxima etapa recomendada

Se você estiver conectado, abra primeiro o Gerenciamento de API e confirme seu chave, status de cota, plano de acesso e a URL de API de usuário exata antes de depurar seu aplicativo externo.

Faça login para configurar chave de API