API Documentation

Base URL:https://api.cybertemp.xyzFree tier has standard processing speed; subscribe for priority access.

Email Retrieval

Temporary Inboxes

Multiple Domains

Subscription Plans

Get your free API key See pricing

How to Use Our API (It's Easy!)

Our API is flexible! Choose FREE access (with a slight delay) or SUBSCRIBE for instant access.

Public API: Accessing General Email Data

Endpoints like getMail or getDomains have two modes:

Standard Speed: API key required, with standard processing queue to ensure fair usage for everyone.
Lightning Fast (Subscribed Users): Use your API key in the X-API-KEY header. This gives you instant responses and higher limits based on your subscription plan.

X-API-KEY: your_subscription_api_key_here

Public API: Free (Standard) or Instant (Priority)

Use this for general email data. Free tier access is processed at standard speed. Subscribe for instant, priority access with higher rate limits.

Bearer Token (for Private Endpoint)

Use the Authorization: Bearer <token> header only for the private endpoint /private/emails. Generate this token in your dashboard. It authenticates you as a specific user to access your personal emails via the API.

Authorization: Bearer your_generated_dashboard_token_here

Private Endpoint Access

The Bearer token links the API request directly to your user account, allowing access to emails associated with your private address. Get your token from the dashboard.

How to Obtain an API Key

API keys are available to all users. Note: instant/no-delay access is only granted when the API key is linked to an active paid subscription plan - otherwise requests are treated as public (subject to standard speed and free-tier rate limits).

Access Settings

Click your profile avatar in the top-right corner, then select "Settings" from the dropdown menu.

Generate API Key

Scroll down to the "API Keys" section and click the "Generate New Key" button. Copy and securely store your API key.

Go to Settings to Manage API Keys

API Access: Super Simple Guide

Public API (general emails, domains): With X-API-KEY = FREE (Non-Priority Queue). With active paid subscription = PRIORITY (Instant).

Private Endpoint (/private/emails): Use Authorization: Bearer <token> (required).

Bearer tokens are generated in the dashboard. API keys are available to all users and can be managed in Settings. Remember: instant/no-delay behavior only applies for keys tied to active paid subscriptions.

Need instant API access? Subscribe to a plan:

View subscription plans

API Rate Limits & Features

Free tier has limits, subscriptions unlock higher performance

Our API requires an API key for all access. The free tier runs at standard processing speed on every request and rate limits apply. Subscribers get instant access with higher rate limits:

Free Tier

API key required

Non-Priority Queue

Eco Plan

€1.99/month

No delay, 20 reqs/sec

Core Plan

€2.99/month

No delay, 50 reqs/sec

Elite Plan

€4.99/month

No delay, Unlimited

Team

€49/month · 5 seats · Elite features for every seat

Multi-seat

Remember: Free Tier Always Available!

An API key is required for all access. The free tier is always available at standard processing speed. Subscriptions remove the delay and increase rate limits.

Code Examples

Implementation examples in different languages

// Public endpoint: Use X-API-KEY
async function getEmails(email, apiKey = null, limit = 25, offset = 0) {
  const headers = apiKey ? { 'X-API-KEY': apiKey } : {};
  const params = new URLSearchParams({ email });
  if (limit !== 25) params.append('limit', limit.toString());
  if (offset > 0) params.append('offset', offset.toString());
  const url = `https://api.cybertemp.xyz/getMail?${params}`;
  const response = await fetch(url, { headers });
  if (!response.ok) { const err = await response.text(); throw new Error('HTTP error! ' + response.status + ': ' + err); }
  return response.json();
}

Prefer a client library? Jump to Client libraries

Webhooks

Get HMAC-SHA256-signed POSTs at your endpoint whenever a message lands in one of your inboxes.

Elite + Team only

Webhooks are part of the Elite tier (€4.99/mo). Team owners and members get them too.

Event types

message.receivedA new email lands in one of your inboxes.
inbox.createdA new inbox was provisioned on your account.
test.pingFired from the dashboard 'Test' button — useful for verifying your endpoint before real mail arrives.

Request headers

X-Cybertemp-Signature: sha256=<hmac_hex>

X-Cybertemp-Event: message.received

X-Cybertemp-Delivery: <unique_id>

X-Cybertemp-Timestamp: <unix_seconds>

Content-Type: application/json

Payload shape

{
  "event": "message.received",
  "delivery_id": "7c4f...",
  "timestamp": 1731234567,
  "data": {
    "inbox_id": "5d2f...",
    "inbox": "[email protected]",
    "message_id": "9a1b...",
    "from": "[email protected]",
    "to": ["[email protected]"],
    "subject": "Your verification code",
    "received_at": "2026-05-17T09:31:00Z",
    "size_bytes": 4732,
    "encrypted": true
  }
}

Verify the signature

HMAC the raw request body with your signing secret and compare against the X-Cybertemp-Signature header using constant-time compare.

import crypto from "node:crypto";
import express from "express";

const app = express();
app.use("/webhooks/cybertemp",
  express.raw({ type: "application/json" }));

app.post("/webhooks/cybertemp", (req, res) => {
  const header = req.header("x-cybertemp-signature") || "";
  const expected = "sha256=" + crypto
    .createHmac("sha256", process.env.CT_WEBHOOK_SECRET)
    .update(req.body)
    .digest("hex");

  if (!crypto.timingSafeEqual(
    Buffer.from(header), Buffer.from(expected)
  )) return res.status(401).end();

  const event = JSON.parse(req.body.toString("utf8"));
  // ...handle event...
  res.status(200).end();
});

Retry policy

On 5xx or timeout we retry with exponential backoff (1m, 5m, 30m, 6h). After 10 consecutive failures we auto-pause the webhook and show a banner in the dashboard. 2xx is treated as success and resets the failure counter.

Manage your webhook endpoints + signing secrets

Open Settings → Webhooks

Client libraries

Published wrappers around the same REST API. Each is a thin client: anything they can do, a plain HTTP request can do too.

Python

PyPI

Install

pip install cybertemp

Use

from cybertemp import CyberTemp

client = CyberTemp(api_key="tk_...")
emails = client.get_email_content("[email protected]")
domains = client.get_domains()

GitHub

Install

go get github.com/sexfrance/cybertemp-go

Use

import cybertemp "github.com/sexfrance/cybertemp-go"

c := cybertemp.New("tk_...")
inbox, _ := c.CreateInbox(ctx, nil)
msg, _ := c.WaitForMessage(ctx, inbox.ID, 60*time.Second, nil)

Rust

crates.io

Install

cargo add cybertemp tokio --features tokio/full

Use

use cybertemp::Client;
use std::time::Duration;

let client = Client::new("tk_...");
let inbox = client.create_inbox().await?;
let msg = client.wait_for_message(&inbox.id, Duration::from_secs(60)).await?;

Node / TypeScript

Install

No package needed: Node 18+ has fetch built in.

Use

const res = await fetch(
  "https://api.cybertemp.xyz/[email protected]",
  { headers: { "X-API-KEY": process.env.CYBERTEMP_API_KEY! } },
);
const emails = await res.json(); // [{ id, from, subject, text, html, date }]

Plan limits return clear errors

Hitting a limit returns HTTP 402 (concurrent inbox cap) or 429 (rate limit) with a JSON error body, so your CI logs show which limit you hit instead of a bare failure.

API endpoints

GET/getMail

Free (Non-Priority) or Priority (with active subscription)

All-in-one Email API! This single endpoint does everything you need:

How getEmails Works:

✓Auto-creates inbox if it doesn't exist.
✓Retrieves all emails for the address.
✓Returns complete content (HTML, Text, Subject, etc.).
✓Domain flexible: Use any domain (e.g. @discord.com), we handle it.
✓Pagination support for large inboxes.

Authentication:

API Key: Fastest. Instant access if subscribed. Add header:

Parameters (Query String):

email

required

Target email address (e.g. [email protected]). Auto-created if new.

limit

optional

Number of emails to return (default 25, max 100).

offset

optional

Pagination offset (default 0).

Example Request:

GET /[email protected]&limit=50&offset=100
X-API-KEY: your_api_key_here

Example Response:

[
  {
    "id": "email:xyz",
    "from": "[email protected]",
    "to": "[email protected]",
    "subject": "Test Email",
    "text": "Email content",
    "html": "<p>Email content</p>",
    "date": "2024-01-01T00:00:00.000Z"
  }
]

// Public endpoint: Use X-API-KEY async function getEmails(email, apiKey = null, limit = 25, offset = 0) { const headers = apiKey ? { 'X-API-KEY': apiKey } : {}; const params = new URLSearchParams({ email }); if (limit !== 25) params.append('limit', limit.toString()); if (offset > 0) params.append('offset', offset.toString()); const url = `https://api.cybertemp.xyz/getMail?${params}`; const response = await fetch(url, { headers }); if (!response.ok) { const err = await response.text(); throw new Error('HTTP error! ' + response.status + ': ' + err); } return response.json(); }

{ "event": "message.received", "delivery_id": "7c4f...", "timestamp": 1731234567, "data": { "inbox_id": "5d2f...", "inbox": "[email protected]", "message_id": "9a1b...", "from": "[email protected]", "to": ["[email protected]"], "subject": "Your verification code", "received_at": "2026-05-17T09:31:00Z", "size_bytes": 4732, "encrypted": true } }

import crypto from "node:crypto"; import express from "express"; const app = express(); app.use("/webhooks/cybertemp", express.raw({ type: "application/json" })); app.post("/webhooks/cybertemp", (req, res) => { const header = req.header("x-cybertemp-signature") || ""; const expected = "sha256=" + crypto .createHmac("sha256", process.env.CT_WEBHOOK_SECRET) .update(req.body) .digest("hex"); if (!crypto.timingSafeEqual( Buffer.from(header), Buffer.from(expected) )) return res.status(401).end(); const event = JSON.parse(req.body.toString("utf8")); // ...handle event... res.status(200).end(); });

use cybertemp::Client; use std::time::Duration; let client = Client::new("tk_..."); let inbox = client.create_inbox().await?; let msg = client.wait_for_message(&inbox.id, Duration::from_secs(60)).await?;

const res = await fetch( "https://api.cybertemp.xyz/[email protected]", { headers: { "X-API-KEY": process.env.CYBERTEMP_API_KEY! } }, ); const emails = await res.json(); // [{ id, from, subject, text, html, date }]

[ { "id": "email:xyz", "from": "[email protected]", "to": "[email protected]", "subject": "Test Email", "text": "Email content", "html": "<p>Email content</p>", "date": "2024-01-01T00:00:00.000Z" } ]