Documentation API

URL de base :https://api.cybertemp.xyzLe niveau gratuit a une vitesse de traitement standard ; abonnez-vous pour un accès prioritaire.

Récupération d'emails

Boîtes temporaires

Domaines multiples

Plans d'abonnement

Obtenez votre clé d'API gratuite Voir les tarifs

Comment utiliser notre API (C'est facile !)

Notre API est flexible ! Choisissez l'accès GRATUIT (avec un léger délai) ou ABONNEZ-VOUS pour un accès instantané.

API Publique : Accès aux données générales

Les points de terminaison comme getMail ou getDomains ont deux modes :

Vitesse Standard : Clé API requise, avec file d'attente de traitement standard pour assurer une utilisation équitable pour tous.
Éclair (Utilisateurs abonnés) : Utilisez votre clé API dans l'en-tête X-API-KEY . Cela vous donne des réponses instantanées et des limites plus élevées selon votre plan.

X-API-KEY: your_subscription_api_key_here

API Publique : Gratuit (Standard) ou Instantané (Priorité)

Utilisez ceci pour les données générales d'email. L'accès au niveau gratuit est traité à vitesse standard. Abonnez-vous pour un accès prioritaire instantané avec des limites plus élevées.

Jeton Bearer (pour point de terminaison privé)

Utilisez l'en-tête Authorization: Bearer <token> uniquement pour le point de terminaison privé /private/emails. Générez ce jeton dans votre tableau de bord. Il vous authentifie en tant qu'utilisateur spécifique pour accéder à vos emails personnels via l'API.

Authorization: Bearer your_generated_dashboard_token_here

Accès au point de terminaison privé

Le jeton Bearer lie la demande API directement à votre compte utilisateur, permettant l'accès aux emails associés à votre adresse privée. Obtenez votre jeton depuis le tableau de bord.

Comment obtenir une clé API

Les clés API sont disponibles pour tous les utilisateurs. Note : l'accès instantané/sans délai n'est accordé que lorsque la clé API est liée à un plan d'abonnement payant actif - sinon les demandes sont traitées comme publiques (soumises à la vitesse standard et aux limites du niveau gratuit).

Connectez-vous à votre compte

Connectez-vous à votre compte CyberTemp avec votre email et mot de passe.

Accédez aux paramètres

Cliquez sur votre avatar de profil en haut à droite, puis sélectionnez "Paramètres" dans le menu déroulant.

Générer une clé API

Faites défiler jusqu'à la section "Clés API" et cliquez sur le bouton "Générer une nouvelle clé". Copiez et conservez votre clé API en sécurité.

Gérer les clés API dans les paramètres

Accès API : Guide Super Simple

API Publique (emails généraux, domaines) : Avec X-API-KEY = GRATUIT (File non prioritaire). Avec abonnement payant actif = PRIORITÉ (Instantané).

Point de terminaison privé (/private/emails) : Utilisez Authorization: Bearer <token> (requis).

Les jetons Bearer sont générés dans le tableau de bord. Les clés API sont disponibles pour tous les utilisateurs et peuvent être gérées dans les paramètres. Rappel : le comportement instantané/sans délai ne s'applique qu'aux clés liées à des abonnements payants actifs.

Besoin d'un accès API instantané ? Abonnez-vous :

Voir les forfaits d'abonnement

Limites et fonctionnalités de l'API

Le niveau gratuit a des limites, les abonnements débloquent de meilleures performances

Notre API nécessite une clé API pour tout accès. Le niveau gratuit a une vitesse de traitement standard pour chaque demande et des limites de taux s'appliquent. Les utilisateurs abonnés obtiennent un accès instantané avec des limites plus élevées :

Niveau Gratuit

Clé API requise

File non prioritaire

Plan Eco

€1.99/mois

Sans délai, 20 req/sec

Plan Core

€2.99/mois

Sans délai, 50 req/sec

Plan Elite

€4.99/mois

Sans délai, Illimité

Team

€49/mois · 5 sièges · fonctionnalités Elite pour chaque siège

Multi-sièges

Rappel : Niveau gratuit toujours disponible !

La clé API est requise pour tout accès. Le niveau gratuit est toujours disponible à vitesse standard. Les abonnements suppriment le délai et augmentent les limites.

Exemples de code

Exemples d'implémentation dans différentes langues

// 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();
}

Vous préférez une bibliothèque cliente ? Accédez à Bibliothèques clientes

Webhooks

Recevez des POST signés HMAC-SHA256 sur votre endpoint à chaque nouveau message dans une de vos boîtes.

Elite + Team uniquement

Les webhooks font partie de l'offre Elite (€4.99/mois). Les propriétaires et membres Team y ont aussi accès.

Types d'événements

message.receivedUn nouvel email arrive dans une de vos boîtes.
inbox.createdUne nouvelle boîte a été provisionnée sur votre compte.
test.pingDéclenché depuis le bouton « Tester » du tableau de bord — utile pour vérifier votre endpoint avant l'arrivée de vrais emails.

En-têtes de la requête

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

Structure du payload

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

Vérifier la signature

Calculez un HMAC du corps brut avec votre secret de signature et comparez-le à l'en-tête X-Cybertemp-Signature avec une comparaison à temps constant.

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();
});

Politique de relance

En cas de 5xx ou timeout, nous relançons avec un backoff exponentiel (1min, 5min, 30min, 6h). Après 10 échecs consécutifs, le webhook est mis en pause automatiquement avec une bannière dans le tableau de bord. Un 2xx est considéré comme un succès et réinitialise le compteur d'échecs.

Gérez vos endpoints + secrets de signature

Ouvrir Paramètres → Webhooks

Bibliothèques clientes

Des wrappers publiés autour de la même API REST. Chacun est un client léger : tout ce qu'ils font, une simple requête HTTP peut le faire aussi.

Python

PyPI

Installation

pip install cybertemp

Utilisation

from cybertemp import CyberTemp

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

GitHub

Installation

go get github.com/sexfrance/cybertemp-go

Utilisation

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

Installation

cargo add cybertemp tokio --features tokio/full

Utilisation

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

Installation

Aucun paquet nécessaire : Node 18+ intègre fetch.

Utilisation

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 }]

Des erreurs claires quand une limite est atteinte

Lorsqu'une limite est atteinte, l'API renvoie HTTP 402 (plafond de boîtes simultanées) ou 429 (limite de débit) avec un corps d'erreur JSON, pour que vos logs de CI indiquent quelle limite a été atteinte au lieu d'un simple échec.

Endpoints de l'API

GET/getMail

Gratuit (Non-Prioritaire) ou Prioritaire (avec abonnement)

API Email tout-en-un ! Ce point de terminaison unique fait tout ce dont vous avez besoin :

Comment fonctionne getEmails :

✓Crée automatiquement la boîte si elle n'existe pas.
✓Récupère tous les emails pour l'adresse.
✓Renvoie le contenu complet (HTML, Texte, Objet, etc.).
✓Domaine flexible : Utilisez n'importe quel domaine (ex. @discord.com), nous le gérons.
✓Support de pagination pour les grandes boîtes.

Authentification :

Clé API : Le plus rapide. Accès instantané si abonné. Ajoutez l'en-tête :

Paramètres (Query String) :

email

requis

Adresse email cible (ex. [email protected]). Créée automatiquement si nouvelle.

limit

facultatif

Nombre d'emails à retourner (défaut 25, max 100).

offset

facultatif

Décalage de pagination (défaut 0).

Exemple de requête :

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

Exemple de réponse :

[
  {
    "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" } ]