Commencer

Documentation API

Numéros, messages et gains, directement depuis votre application.

GET

Commencez par une seule demande

13 · Commandes APIREST + handler_api.phpJSON / plain text · Bearer

Créez une clé API dans votre tableau de bord, obtenez un numéro et vérifiez les messages toutes 20 secondes. Le paiement est crédité lorsqu’un SMS avec un code arrive ; le rélectrement ne affecte pas votre solde.

REST APIhttps://smscash.org/api/v1

Compatibilité API base URLhttps://smscash.org/stubs/handler_api.php

Le service est en vienuméros de téléphone, SMS Les revenus sont disponibles, les retraites sont disponibles USDT sur TRC20Les paiements se font entre 1 et 45 Les jours.

Démarrage rapide · REST / cURL

curl -X POST 'https://smscash.org/api/v1/activations' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: request-unique-001' \
  -d '{"service":"go","country":86}'

Adresse d'interface compatible alternative : /handler_api.php. Les intégrations REST existantes continuent de fonctionner.

REST API

Générateur de requêtes

cURL · Go · JS · Python

DemandeService APIPays APIOpérateur operatorCode propriétaire du logiciel refIdempotency-Key

Idempotency-Key: UUID · POST · 8–128

Sélection automatique : le plus de codes sur la dernière heure, puis sur 24 heures. Aucun numéro : opérateur suivant.

cURL

curl --max-time 15 --fail-with-body -X POST 'https://smscash.org/api/v1/activations' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: request-unique-001' \
  --data '{"service":"go","country":86}'

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
  "os"
  "time"
)

func main() {
  payload := []byte("{\"service\":\"go\",\"country\":86}")
  req, err := http.NewRequest("POST", "https://smscash.org/api/v1/activations", bytes.NewReader(payload))
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer " + os.Getenv("SMSCASH_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("Idempotency-Key", "request-unique-001")
  client := &http.Client{Timeout: 15 * time.Second, CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}
  res, err := client.Do(req)
  if err != nil { panic(err) } // Keep the same operation key after a network error.
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil { panic(err) }
  if res.StatusCode >= 300 {
    fmt.Fprintf(os.Stderr, "HTTP %d, request_id=%s\n%s\n", res.StatusCode, res.Header.Get("X-Request-ID"), body)
    os.Exit(1)
  }
  fmt.Println(string(body))
}

JavaScript

// Node.js 18+: set SMSCASH_API_KEY in your environment.
const response = await fetch("https://smscash.org/api/v1/activations", {
  method: "POST",
  headers: {
    Authorization: 'Bearer ' + process.env.SMSCASH_API_KEY,
    'Content-Type': 'application/json',
    'Idempotency-Key': "request-unique-001",
  },
  body: JSON.stringify({
  "service": "go",
  "country": 86
}),
  signal: AbortSignal.timeout(15000),
  redirect: 'error',
});
const result = await response.json();
if (!response.ok) {
  const error = result.error || {};
  console.error(response.status, error.code, error.hint, error.request_id);
  throw new Error(error.message || 'API error');
}
console.log(result);
// SMS codes are strings: keep leading zeros. Never retry writes automatically.

Python

import json
import os
import urllib.error
import urllib.request

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

headers = {
    'Authorization': 'Bearer ' + os.environ['SMSCASH_API_KEY'],
    'Content-Type': 'application/json',
    'Idempotency-Key': "request-unique-001",
}
request = urllib.request.Request(
    "https://smscash.org/api/v1/activations",
    headers=headers,
    data="{\"service\":\"go\",\"country\":86}".encode('utf-8'),
    method="POST",
)
try:
    with urllib.request.build_opener(NoRedirect).open(request, timeout=15) as response:
        result = json.load(response)
    print(result)
except urllib.error.HTTPError as error:
    details = json.load(error).get('error', {})
    print(error.code, details.get('code'), details.get('hint'), details.get('request_id'))
    raise
# No automatic retries; SMS codes remain strings.

Clé API

La clé n’est pas enregistrée. Cette vérification n’attribue aucun numéro.

REST pour de nouvelles intégrations

Services et pays

Choisissez un service et un pays. La rémunération par SMS dépend du pays.

REST

GET /api/v1/catalog?service=go&country=86&page=1&page_size=100
Authorization: Bearer YOUR_API_KEY

JSON

{
  "rows": [
    {
      "offer_id": 42,
      "service": "go",
      "service_name": "Google",
      "country_id": 86,
      "country_name": "Italy",
      "provider_id": 1,
      "operator": 1,
      "provider_name": "Operator 1",
      "reward": "0.00300000",
      "currency": "USD",
      "accounting_precision": 8,
      "earnings_hold_days": 45
    }
  ],
  "page": 1,
  "page_size": 100,
  "total": 1,
  "pages": 1,
  "has_more": false,
  "accounting_precision": 8
}

service · country · operator · q · page · page_size (1–100)

Obtenez un numéro

REST

POST /api/v1/activations
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
Idempotency-Key: request-unique-001

{
  "service": "go",
  "country": 86
}

Sélection automatique : le plus de codes sur la dernière heure, puis sur 24 heures. Aucun numéro : opérateur suivant.

REST

201: new session · 200: replay of the same operation
service + country OR offer_id · duration_minutes: 20
ref: software owner code (optional)
operator: public ID (e.g. 1 for Operator 1), optional · any/0: automatic
country: integer · service: string · SMS code: string

Le nombre est valide pendant 20 minutes. SMS est vérifié tous les 20 secondes. Vous pouvez annuler immédiatement.

Vérifier plusieurs numéros

REST

GET /api/v1/activations/batch?ids=42,43
Authorization: Bearer YOUR_API_KEY

JSON

{
  "rows": [
    {
      "id": 42,
      "found": true,
      "phone": "12025550123",
      "status": "received",
      "service": "go",
      "country_id": 86,
      "provider_id": 1,
      "operator": 1,
      "expires_at": "2026-10-10T12:15:00Z",
      "sms_count": 1,
      "code": "001234",
      "last_sms": {
        "id": 101,
        "code": "001234",
        "sender": "Service",
        "text": "Code: 001234",
        "received_at": "2026-10-10T12:01:00Z"
      }
    },
    {
      "id": 43,
      "found": false,
      "error": {
        "code": "NO_ACTIVATION",
        "message": "Session not found."
      }
    }
  ],
  "as_of": "2026-10-10T12:01:00Z",
  "poll_interval_seconds": 20
}

REST

ids: 1–100 positive session IDs, separated by commas
Input order preserved · duplicates removed
Foreign, unavailable or out-of-scope IDs: found=false
Read only · no supplier requests · last_sms is the latest message

Solde · Bloqué

REST

GET /api/v1/balance
Authorization: Bearer YOUR_API_KEY

JSON

{
  "currency": "USD",
  "accounting_precision": 8,
  "balance": "12.00000000",
  "held_balance": "34.50000001",
  "balance_minor": "1200000000",
  "held_minor": "3450000001",
  "as_of": "2026-10-12T20:00:00Z",
  "next_release_at": "2026-11-26T20:00:00Z"
}

balance — Disponible; held_balance — Bloqué. USD · 8

Seuls les fonds dont la durée de blocage est terminée peuvent être retirés.

Clients prêts à l’emploi

JavaScript / Node.js ↓Python ↓

JavaScript · Node.js 18+

import {SmScash, SmScashError} from './smscash.mjs';
import {randomUUID} from 'node:crypto';

const api = new SmScash(process.env.SMSCASH_API_KEY);
const catalog = await api.catalog({service: 'go', country: 86});
console.log(catalog.rows);

// Save this key before sending; keep it for retries of this operation.
const requestKey = randomUUID();
const session = await api.createNumber({service: 'go', country: 86}, requestKey);
// After 20 seconds:
const messages = await api.sms(session.id, {afterId: 0});
console.log(messages.sms);
const statuses = await api.batch([session.id]);
const held = await api.holdBalance();
console.log(held); // Exact USD string

Python 3.9+

import os
import uuid
from smscash import SmScash, SmScashError

api = SmScash(os.environ['SMSCASH_API_KEY'])
catalog = api.catalog(service='go', country=86)
print(catalog['rows'])

# Save this key before sending; keep it for retries of this operation.
request_key = str(uuid.uuid4())
session = api.create_number({'service': 'go', 'country': 86}, request_key)
# After 20 seconds:
messages = api.sms(session['id'], after_id=0)
print(messages['sms'])
statuses = api.batch([session['id']])
held = api.hold_balance()
print(held) # Exact USD string

SDK

me() · balance() · holdBalance()/hold_balance() · catalog() · activation() · sms() · batch()
createNumber(parameters, requestKey) / create_number(parameters, request_key)
setStatus(id, "cancel") / set_status(id, "cancel")
setStatus(id, "retry", requestKey) / set_status(id, "retry", request_key)
Timeout: 15 s · no dependencies · no automatic retries
Error: code · status · hint · requestId/request_id · retryable
ALLOCATION_UNCERTAIN: contact support with request_id; never retry automatically.

SMS-Activate / HeroSMS

SMS-Activate · Compatibilité API base URLhttps://smscash.org/sms-activate/stubs/handler_api.php

HeroSMS · Compatibilité API base URLhttps://smscash.org/hero-sms/stubs/handler_api.php

Clé API personnelle de l’utilisateur.

Choisissez un service et un pays. La rémunération par SMS dépend du pays.

Coder	Descriptif
`getNumber / getNumberV2`	Obtenez un numéro
`getStatus / getStatusV2`	Obtenez le dernier code
`setStatus / finishActivation / cancelActivation`	Gérer la session
`getPrices / getNumbersStatus`	Vérifier la disponibilité
`getRewards (SMScash)`	Récompense pour SMS
`getServicesList / getServices`	Prestations
`getCountries / getOperators`	Services et pays
`getActiveActivations`	Séances
`getBalance`	Solde de l’utilisateur
`getHoldBalance (SMScash)`	Bloqué

cost = 0 USD · activationCost = 0 USD
reward — Récompense pour SMS

HeroSMS · cURL

curl --get 'https://smscash.org/hero-sms/stubs/handler_api.php' \
  --data-urlencode 'api_key=YOUR_API_KEY' \
  --data-urlencode 'action=getNumberV2' \
  --data-urlencode 'service=go' \
  --data-urlencode 'country=86' \
  -H 'Idempotency-Key: request-unique-001'

Réponses

{
  "activationId": "42",
  "phoneNumber": "393331234567",
  "activationCost": 0,
  "currency": 840,
  "countryCode": 86,
  "canGetAnotherSms": true,
  "activationTime": "2026-10-11T12:00:00Z",
  "activationEndTime": "2026-10-11T12:15:00Z",
  "reward": "0.00300000"
}

SMS-Activate / HeroSMS

GET or POST application/x-www-form-urlencoded
api_key · action · service · country · ref (optional)
setStatus: 1 → ACCESS_READY · 3 → ACCESS_RETRY_GET
           6 → ACCESS_ACTIVATION · 8 → ACCESS_CANCEL
getStatus: STATUS_WAIT_CODE · STATUS_OK:001234 · STATUS_CANCEL
getStatusV2: {"verificationType":1,"sms":null,"call":null}
getServicesList: {"status":"success","services":[{"code":"go","name":"Google"}]}
getCountries: {"86":{"id":86,"eng":"Italy","visible":1,"retry":1,"rent":0}}
getPrices: {"86":{"go":{"cost":0,"count":12,"reward":"0.00300000","currency":"USD"}}}
getRewards: {"59":{"vi":{"1":"0.01000000"}}}
getRewards filters: country · service · operator (optional); any/0: all permitted providers
getActiveActivations: start=0 · limit=1–100 · activeActivations / data
Business/key errors: HTTP 200 + plain text · server errors: HTTP 500
Availability: actual supplier pool, shared cache up to 20 s; not a reservation
No automatic retries after a transport error or ALLOCATION_UNCERTAIN.
Keep the original Idempotency-Key and parameters.
Unsupported: rent · calls · forwarding · multiple services per number · prolong
Unsupported options return BAD_REQUEST; unsupported actions return BAD_ACTION.
SMScash keys and country/service codes; configure this base URL in your software.

Le nombre est valide pendant 20 minutes. SMS est vérifié tous les 20 secondes. Vous pouvez annuler immédiatement.

Authentification et nouvelles tentatives

REST: en-tête Authorization: Bearer YOUR_API_KEY. Interfaces compatibles : paramètres api_key et action. Utilisez HTTPS.

Pour gérer les clés API, entrez votre compte.

∞requêtes/min par compte

∞séances simultanées

La fréquence des requêtes et le nombre de numéros de téléphone sont illimités. Il n’existe aucun quota journalier ou horaire.

Le nombre est valide pendant 20 minutes. SMS est vérifié tous les 20 secondes. Vous pouvez annuler immédiatement.

Dans REST, un unique Idempotency-Key est requis pour l’attribution de numéros, l’attribution répétée, retry et les demandes de paiement. C'est facultatif mais recommandé dans handler_api.php. Réutilisez la clé lorsque vous réessayez une requête réseau ; utiliser une nouvelle clé pour une nouvelle opération.

Portée de la clé API

Vous pouvez associer une clé à des services, pays et fournisseurs précis. Les listes vides autorisent toutes les options disponibles.

JSON

{
  "label": "Mon logiciel",
  "policy": {
    "services": [
      "go"
    ],
    "countries": [
      86
    ],
    "providers": [
      1
    ]
  }
}

PATCH /api/v1/keys/{id} change entièrement le nom et policy. Le secret n'est affiché qu'une fois créé.

10% au total. 5% + 5% avec code logiciel.

Lors de l'émission d'un numéro, veuillez fournir ref propriétaire du logiciel. La demande est autorisée par la clé de l'utilisateur testamentaire. Le code est dans la section "Références" et dans GET /api/v1/referrals → software_ref.

Demande	Parrain	Logiciel
Sans ref	10%	—
Avec ref	5%	5%
Avec ref, pas de référent	—	5%

La plateforme verse la prime sans réduire les revenus du utilisateur. Le propriétaire du logiciel et le référent peuvent être la même personne. Un utilisateur ne peut pas utiliser son propre code.

Les termes sont fixés lors de la création d’une session ; la lecture de SMS et retry ne les modifie pas. Passer ref à nouveau permet une nouvelle session de répétition. Dans le calcul du tarif, une récompense pour le utilisateur de USD 0.003 donne USD 0.00015 chacun au propriétaire et au référent du logiciel. Le bonus total est USD 0.00030.

Commandes API

11 méthodes de style XVBC plus votre balance SMScash.

GETgetNumberObtenez un numéro

Crée une session et réserve un numéro disponible pour l’utilisateur. Le tarif et les bénéficiaires des primes de parrainage sont fixés lors de l’attribution ; la rémunération est créditée à la réception d’un SMS contenant un code.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`service`*	string	Codes de service disponibles. La réponse est limitée à la zone de la clé API.
`country`*	integer	Prenez ID de getCountries.
`operator`	string	Prenez ID de operators/getOperators (API). `operator=1 · any/0`
`session_duration`	integer	La séance dure 20 minutes. Passer 20 ou omettre ce paramètre.
`with_operator`	integer	1 ajoute l’ID de l’opérateur à la réponse ; 0 ou son omission renvoie trois segments.
`ref`	string	Code public du propriétaire du logiciel : 5% pour lui et 5% pour l'invitant. Sans ref - 10% à l'invitant.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getNumber.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getNumber&api_key=YOUR_API_KEY&service=go&country=86&with_operator=1' \
  -H 'Idempotency-Key: request-unique-001'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getNumber&api_key=YOUR_API_KEY&service=go&country=86&with_operator=1", nil)
  if err != nil { panic(err) }
  req.Header.Set("Idempotency-Key", "request-unique-001")
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getNumber&api_key=YOUR_API_KEY&service=go&country=86&with_operator=1", {
  headers: {"Idempotency-Key": "request-unique-001"}
});
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getNumber&api_key=YOUR_API_KEY&service=go&country=86&with_operator=1",
    headers={"Idempotency-Key": "request-unique-001"},
    timeout=15,
)
print(response.status_code, response.text)

Réponses

Numéro émis

ACCESS_NUMBER:42:380670000000:1

Aucun numéro disponible

EMPTY_POOL

Sélection automatique : le plus de codes sur la dernière heure, puis sur 24 heures. Aucun numéro : opérateur suivant.
Passer Idempotency-Key : la même requête avec la même clé renvoie la session précédente. La modification des paramètres appelle IDEMPOTENCY_CONFLICT.
Un pays numérique sans pool donne EMPTY_POOL ; le mauvais format de pays est BAD_COUNTRY.
La clé d’une session supprimée reste utilisée : la réinitialisation de l’allocation avec cette clé renvoie SESSION_CLOSED et ne génère pas un autre numéro.
Le résultat de l’attribution n’est pas confirmé. La relance automatique est désactivée pour éviter d’attribuer un deuxième numéro.

GETgetNumbersStatusVérifier la disponibilité

Nombre de numéros de téléphone disponibles par service et pays.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`country`*	integer	Prenez ID de getCountries.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getNumbersStatus.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getNumbersStatus&api_key=YOUR_API_KEY&country=86'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getNumbersStatus&api_key=YOUR_API_KEY&country=86", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getNumbersStatus&api_key=YOUR_API_KEY&country=86");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getNumbersStatus&api_key=YOUR_API_KEY&country=86",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

Numéros disponibles

{
  "go_0": 0
}

Le suffixe _0 signifie un choix sans opérateur spécifique.
La disponibilité concerne l’ensemble des numéros du fournisseur. Le canal choisi est vérifié lors de l’attribution.

GETgetStatusObtenez le dernier code

Demande facile de l'état de la session et du dernier code SMS. Les zéros non significatifs du code sont conservés.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`id`*	integer	ID de votre session, reçu lors de l'émission du numéro.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getStatus.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getStatus&api_key=YOUR_API_KEY&id=42'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getStatus&api_key=YOUR_API_KEY&id=42", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getStatus&api_key=YOUR_API_KEY&id=42");
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getStatus&api_key=YOUR_API_KEY&id=42",
    timeout=15,
)
print(response.status_code, response.text)

Réponses

En attente

STATUS_WAIT_CODE

Code reçu

STATUS_OK:001234

Annulation ou expiration

STATUS_CANCEL

Pas trouvé

NO_ACTIVATION

Vérifiez toutes les 20 secondes. Lire un message à nouveau ne génère pas de nouvelle paiement.
Après retry, l'ancien code n'est pas renvoyé : getStatus attend le prochain SMS.
Après que un nombre sans SMS soit supprimé, getStatus et getSms retournent à STATUS_CANCEL ; getSmsFull retourne l’état fermé, un téléphone vide et une liste SMS vide. REST /activations/{id} et /sms retournent 404 NO_ACTIVATION.

GETsetStatusGérer la session

Terminaisons, annulation ou reprise de l’attente pour SMS. Expiration de la session reste inchangée.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`id`*	integer	ID de votre session, reçu lors de l'émission du numéro.
`status`*	integer	3 — attendez le prochain code sans prolonger la session ; 6 — terminez après SMS ; 8 — annulez immédiatement.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=setStatus.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=setStatus&api_key=YOUR_API_KEY&id=42&status=3' \
  -H 'Idempotency-Key: request-unique-001'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=setStatus&api_key=YOUR_API_KEY&id=42&status=3", nil)
  if err != nil { panic(err) }
  req.Header.Set("Idempotency-Key", "request-unique-001")
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=setStatus&api_key=YOUR_API_KEY&id=42&status=3", {
  headers: {"Idempotency-Key": "request-unique-001"}
});
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=setStatus&api_key=YOUR_API_KEY&id=42&status=3",
    headers={"Idempotency-Key": "request-unique-001"},
    timeout=15,
)
print(response.status_code, response.text)

Réponses

En attendant SMS

ACCESS_RETRY_GET

Terminé

ACCESS_ACTIVATION

Annulé

ACCESS_CANCEL

Réessayer, attendre le prochain code dans les 20 minutes initiales. Les horaires de problème et d'expiration ne changent pas.
Pour status=3, utilisez Idempotency-Key : répéter la demande ne réinitialisera pas le nouveau code déjà reçu. L’historique du SMS reste disponible.
L’annulation ne retire pas les gains déjà acquis.
Seuls les numéros portant un code SMS sont conservés dans l’histoire. Les numéros annulés et expirés sans code sont supprimés.

GETgetRepeatNumberÉmettez à nouveau le même numéro

Ouvre une nouvelle session avec un numéro spécifique de votre historique. Vous pouvez sélectionner un autre service disponible dans le même pays.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`number`*	string	Votre ancien numéro. Seuls les chiffres et un + facultatif sont autorisés.
`service`*	string	Codes de service disponibles. La réponse est limitée à la zone de la clé API.
`session_duration`	integer	La séance dure 20 minutes. Passer 20 ou omettre ce paramètre.
`with_operator`	integer	1 ajoute l’ID de l’opérateur à la réponse ; 0 ou son omission renvoie trois segments.
`ref`	string	Code public du propriétaire du logiciel : 5% pour lui et 5% pour l'invitant. Sans ref - 10% à l'invitant.
`operator`	string	Prenez ID de operators/getOperators (API). `operator=1 · any/0`

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getRepeatNumber.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getRepeatNumber&api_key=YOUR_API_KEY&number=380670000000&service=go' \
  -H 'Idempotency-Key: request-unique-001'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getRepeatNumber&api_key=YOUR_API_KEY&number=380670000000&service=go", nil)
  if err != nil { panic(err) }
  req.Header.Set("Idempotency-Key", "request-unique-001")
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getRepeatNumber&api_key=YOUR_API_KEY&number=380670000000&service=go", {
  headers: {"Idempotency-Key": "request-unique-001"}
});
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getRepeatNumber&api_key=YOUR_API_KEY&number=380670000000&service=go",
    headers={"Idempotency-Key": "request-unique-001"},
    timeout=15,
)
print(response.status_code, response.text)

Réponses

Nouvelle séance

ACCESS_NUMBER:43:380670000000

Le numéro est toujours occupé

NUMBER_IN_USE

Tout d’abord, terminez ou annulez votre session en cours. Si le numéro est occupé, la réémission n'est pas effectuée.
La nouvelle session reçoit un nouveau ID et le tarif en vigueur. Les anciens SMS n'y sont pas copiés. ref est à nouveau défini.
SMScash permet de répéter uniquement les numéros de l'historique de ce compte. Le pays est identifié par un numéro.
La clé d’une session supprimée reste utilisée : la réinitialisation de l’allocation avec cette clé renvoie SESSION_CLOSED et ne génère pas un autre numéro.

GETgetSmsFullObtenez SMS en tant que JSON

Historique structuré de tous les messages avec ID, expéditeur, code, texte et données de pays, de service et de fournisseur.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`id`*	integer	ID de votre session, reçu lors de l'émission du numéro.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getSmsFull.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getSmsFull&api_key=YOUR_API_KEY&id=42'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getSmsFull&api_key=YOUR_API_KEY&id=42", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getSmsFull&api_key=YOUR_API_KEY&id=42");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getSmsFull&api_key=YOUR_API_KEY&id=42",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

JSON

{
  "success": true,
  "session_id": 42,
  "phone": "380670000000",
  "status": 1,
  "status_name": "received",
  "sms_count": 1,
  "sms": [
    {
      "id": 101,
      "external_id": "message-101",
      "sender": "Service",
      "code": "001234",
      "text": "Код подтверждения: 001234",
      "received_at": "2026-10-09T12:00:00Z",
      "country": {
        "id": 86,
        "name": "Italy"
      },
      "service": {
        "code": "go",
        "name": "Google"
      },
      "provider": {
        "id": 1,
        "name": "Оператор 1"
      }
    }
  ],
  "expires_at": "2026-10-09T12:20:00Z"
}

Format préféré pour l'intégration. N'oubliez pas sms[].id pour traiter uniquement les nouveaux messages.
Statut numérique SMScash : 1 - actif, 6 - terminé, 8 - annulé ou expiré. status_name fait la distinction entre en attente, reçu, terminé, annulé, expiré.
Les codes reçus restent disponibles après la fin d’une session. Pour de grandes quantités, utilisez REST /activations/{id}/sms avec after_id.
Après que un nombre sans SMS soit supprimé, getStatus et getSms retournent à STATUS_CANCEL ; getSmsFull retourne l’état fermé, un téléphone vide et une liste SMS vide. REST /activations/{id} et /sms retournent 404 NO_ACTIVATION.

GETgetSmsObtenez SMS sous forme de chaîne de texte

Renvoie l'intégralité de l'historique SMS au format chaîne pour les clients existants.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`id`*	integer	ID de votre session, reçu lors de l'émission du numéro.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getSms.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getSms&api_key=YOUR_API_KEY&id=42'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getSms&api_key=YOUR_API_KEY&id=42", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getSms&api_key=YOUR_API_KEY&id=42");
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getSms&api_key=YOUR_API_KEY&id=42",
    timeout=15,
)
print(response.status_code, response.text)

Réponses

Message

STATUS_OK:2026-10-09T12:00:00Z|001234|Код подтверждения: 001234

En attente

STATUS_WAIT_CODE

Annulation ou expiration

STATUS_CANCEL

Format du message : heure|code|texte. Plusieurs messages sont séparés par deux points.
Le texte SMS lui-même peut contenir des deux-points et des barres verticales. Pour une analyse fiable, utilisez getSmsFull.

GETgetServicesPrestations

Codes de service disponibles. La réponse est limitée à la zone de la clé API.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`country`	integer	Prenez ID de getCountries.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getServices.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getServices&api_key=YOUR_API_KEY'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getServices&api_key=YOUR_API_KEY", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getServices&api_key=YOUR_API_KEY");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getServices&api_key=YOUR_API_KEY",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

Prestations

{
  "go": {
    "name": "Google",
    "code": "go"
  }
}

Le répertoire de services est partagé par tous les fournisseurs. L’disponibilité du nombre est vérifiée séparément.

GETgetCountriesPays

Identifiants, noms et codes de appel pour les pays dans le canal sélectionné.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getCountries.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getCountries&api_key=YOUR_API_KEY'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getCountries&api_key=YOUR_API_KEY", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getCountries&api_key=YOUR_API_KEY");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getCountries&api_key=YOUR_API_KEY",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

Pays

{
  "86": {
    "id": 86,
    "name": "Italy",
    "phone_code": "39"
  }
}

GETgetOperatorsOpérateurs

Opérateurs disponibles : identifiant API, nom et durée de retenue.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`country`	integer	Prenez ID de getCountries.
`operator`	string	Prenez ID de operators/getOperators (API). `operator=1 · any/0`

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getOperators.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getOperators&api_key=YOUR_API_KEY'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getOperators&api_key=YOUR_API_KEY", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getOperators&api_key=YOUR_API_KEY");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getOperators&api_key=YOUR_API_KEY",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

Opérateurs

{
  "1": {
    "id": 1,
    "provider_id": 1,
    "operator": 1,
    "name": "Оператор 1",
    "earnings_hold_days": 45
  }
}

Prenez ID de operators/getOperators (API).

GETgetRewardsRécompense pour SMS

Les taux dépendent du pays. Toutes les montants indiqués dans le tableau sont pour un paiement SMS.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.
`country`	integer	Prenez ID de getCountries.
`service`	string	Codes de service disponibles. La réponse est limitée à la zone de la clé API.
`operator`	string	Prenez ID de operators/getOperators (API). `operator=1 · any/0`

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getRewards.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getRewards&api_key=YOUR_API_KEY&country=59&service=vi'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getRewards&api_key=YOUR_API_KEY&country=59&service=vi", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getRewards&api_key=YOUR_API_KEY&country=59&service=vi");
const result = await response.json();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getRewards&api_key=YOUR_API_KEY&country=59&service=vi",
    timeout=15,
)
print(response.status_code, response.json())

Réponses

JSON

{
  "59": {
    "vi": {
      "1": "0.01000000",
      "3": "0.00500000"
    }
  }
}

{}

{}

USD Les montants de tarif sont renvoyés sous forme de chaînes décimales exactes avec 8 décimales :
Fournisseurs activés disponibles pour votre clé.
country ID → service code → operator ID → reward (USD)

GETgetBalanceSolde de l’utilisateur

Ajout SMScash : solde disponible prenant en compte les cumuls, les primes de parrainage et les demandes de paiement.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getBalance.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getBalance&api_key=YOUR_API_KEY'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getBalance&api_key=YOUR_API_KEY", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getBalance&api_key=YOUR_API_KEY");
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getBalance&api_key=YOUR_API_KEY",
    timeout=15,
)
print(response.status_code, response.text)

Réponses

Solde

ACCESS_BALANCE:0.00

getBalance renvoie le solde disponible en USD avec jusqu’à 8 décimales.
Seuls les fonds dont la durée de blocage est terminée peuvent être retirés.

GETgetHoldBalanceBloqué

Après réception d’un SMS, les gains sont bloqués pendant la durée définie par le fournisseur. À la date indiquée, le montant devient automatiquement disponible au retrait.

Paramètres

Paramètre	Tapez	Descriptif
`api_key`*	string	Clé API personnelle de l’utilisateur.

* Paramètre obligatoire. Dans toutes les requêtes, transmettez également action=getHoldBalance.

Exemple de demande

curl

curl 'https://smscash.org/stubs/handler_api.php?action=getHoldBalance&api_key=YOUR_API_KEY'

package main

import (
  "fmt"
  "io"
  "net/http"
  "time"
)

func main() {
  req, err := http.NewRequest("GET", "https://smscash.org/stubs/handler_api.php?action=getHoldBalance&api_key=YOUR_API_KEY", nil)
  if err != nil { panic(err) }
  client := &http.Client{Timeout: 15 * time.Second}
  resp, err := client.Do(req)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, err := io.ReadAll(resp.Body)
  if err != nil { panic(err) }
  fmt.Println(resp.StatusCode, string(body))
}

javascript

const response = await fetch("https://smscash.org/stubs/handler_api.php?action=getHoldBalance&api_key=YOUR_API_KEY");
const result = await response.text();
console.log(response.status, result);

python

import requests

response = requests.get(
    "https://smscash.org/stubs/handler_api.php?action=getHoldBalance&api_key=YOUR_API_KEY",
    timeout=15,
)
print(response.status_code, response.text)

Réponses

Bloqué

ACCESS_HOLD_BALANCE:34.50000001

SMScash · getHoldBalance · USD · 8
Seuls les fonds dont la durée de blocage est terminée peuvent être retirés.

Codes de réponse et demandes répétées

Dans handler_api.php, les résultats commerciaux sont généralement accompagnés de HTTP 200. Vérifiez le corps du texte. Les répertoires et getSmsFull renvoient JSON en cas de succès ; les erreurs sont toujours du texte.

Coder	HTTP	Cause et prochaine étape
`TARIFF_NOT_CONFIGURED`	200	Les tarifs ne sont pas encore fixésL’attribution des numéros commencera dès que les récompenses SMS sont configurées.
`COUNTRY_BLOCKED`	200	L’attribution des numéros pour ce pays est bloquée.Choisissez un autre pays.
`BAD_SERVICE`	200	L’attribution de numéros pour ce service est bloquée.Choisissez un autre service.
`PROVIDER_NOT_READY`	200	L’attribution des numéros est temporairement indisponibleActualisez les catalogues d'API.
`BAD_KEY`	400	Pas de api_key ou format invalide.Vérifiez la clé dans la demande.
`INVALID_API_KEY`	401	La clé est inconnue, révoquée ou le compte est désactivé.Créez une clé API valide.
`BAD_COUNTRY`	400	le pays manque ou n'est pas un nombre positif.Prenez ID de getCountries.
`BAD_SESSION_DURATION`	400	Les numéros de téléphone sont délivrés pour exactement 20 minutes.Corrigez session_duration.
`BAD_REQUEST`	400	Paramètre invalide ou Idempotency-Key.Merci de corriger votre demande.
`BAD_SERVICE / BAD_OPERATOR / INVALID_PROVIDER`	200	Élément de répertoire inconnu ou désactivé.Actualisez les catalogues d'API.
`BAD_NUMBER`	200	Format de numéro incorrect.Donnez le numéro en chiffres.
`BAD_ACTION / BAD_STATUS`	200	Commande, ID ou opération inconnue.Vérifiez les paramètres.
`EMPTY_POOL`	200	Aucun numéro de téléphone correspondant n’est actuellement disponible.Répétez après 10 à 30 secondes ou changez les filtres.
`NUMBER_IN_USE`	200	Un numéro spécifique est occupé par une session active.Terminez votre session ou sélectionnez un autre numéro.
`NO_ACTIVATION`	200	La session ou le numéro précédent n'appartient pas à votre compte.Vérifiez ID et la clé.
`SESSION_CLOSED / SMS_REQUIRED`	200	La transition d’état n’est actuellement pas disponible.Vérifiez l'état et la disponibilité du SMS.
`SCOPE_BLOCKED`	200	Le service, le pays ou le fournisseur n'est pas autorisé à utiliser la clé.Mettez à jour la portée de la clé API.
`IDEMPOTENCY_CONFLICT`	200	Cette clé de requête est déjà associée à d'autres paramètres.Pour une nouvelle opération, créez un autre Idempotency-Key.
`BAD_REF / SELF_REF`	400	Le code du logiciel est inconnu, désactivé ou appartient au utilisateur lui-même.Transmettez le code du propriétaire du logiciel.
`INTERNAL_ERROR`	500	Erreur temporaire du serveur ou du fournisseur.Répétez avec un retard et le même Idempotency-Key.
`ALLOCATION_PENDING`	200	L’attribution du numéro est déjà en cours. Réessaie avec le même Idempotency-Key.L’attribution du numéro est déjà en cours. Réessaie avec le même Idempotency-Key.
`ALLOCATION_UNCERTAIN`	200	Le résultat de l’attribution n’est pas confirmé. La relance automatique est désactivée pour éviter d’attribuer un deuxième numéro.Le résultat de l’attribution n’est pas confirmé. La relance automatique est désactivée pour éviter d’attribuer un deuxième numéro.

REST renvoie un objet {"error":{"code":"…","message":"…"}} et statuts HTTP réguliers 400/401/403/404/409/503.

JSON

{
  "error": {
    "code": "BAD_REQUEST",
    "message": "Vérifiez les champs de la demande.",
    "request_id": "req_…",
    "hint": "Use the documented JSON type; numbers must not be quoted.",
    "retryable": false,
    "details": {
      "field": "country",
      "expected": "integer"
    }
  }
}

REST

X-Request-ID: included in every API response
405: Allow lists the supported HTTP methods
ALLOCATION_PENDING: retryable=true · Retry-After=3 · same operation key
ALLOCATION_UNCERTAIN: retryable=false · contact support
Transport errors: check the operation before another write; keep the original key.

REST pour de nouvelles intégrations

USD Les montants de tarif sont renvoyés sous forme de chaînes décimales exactes avec 8 décimales : 0.00300000 USD.

Le solde est exprimé en USD. Les schémas de requête et de réponse sont disponibles dans OpenAPI.

Retrait en USDT · TRC20Le délai de paiement est de 1 à 45 jours. Les frais de retrait sont de 4 $. Ils sont déduits du montant demandé. Après réception d’un SMS, les gains sont bloqués pendant la durée définie par le fournisseur. À la date indiquée, le montant devient automatiquement disponible au retrait. Seuls les fonds dont la durée de blocage est terminée peuvent être retirés.

GET/api/v1/catalogServices et pays

GET/api/v1/tariffsSMS taux de récompense par pays

GET/api/v1/offersTarifs et récompenses

GET/api/v1/servicesAnnuaire

GET/api/v1/countriesAnnuaire

GET/api/v1/operatorsAnnuaire

GET/api/v1/availability?country=1Disponibilité du numéro

POST/api/v1/activationsNouvelle séance

GET/api/v1/activations/batch?ids=42,43Vérifier plusieurs numéros

GET/api/v1/activationsDernières 200 sessions : scope=history, en attente ou toutes

GET/api/v1/activations/{id}Séance et messages

GET/api/v1/activations/{id}/sms?after_id=0&limit=100Nouveau SMS avec curseur

POST/api/v1/activations/{id}/retryEn attendant SMS

POST/api/v1/activations/{id}/finishAchèvement

POST/api/v1/activations/{id}/cancelAnnuler

POST/api/v1/activations/repeatRéédition du numéro

GET/api/v1/keysClés API

POST/api/v1/keysCréer une clé

PATCH/api/v1/keys/{id}Changer de nom ou policy

DELETE/api/v1/keys/{id}Révoquer la clé

GET/api/v1/referralsCode de parrainage et gains

GET/api/v1/summarySolde et résumé

GET/api/v1/balanceBloqué

GET/api/v1/ledgerGrand livre des bénéfices

GET/api/v1/withdrawalsDemandes de paiement

POST/api/v1/withdrawalsCréer une demande

GET/api/v1/statisticsStatistiques générales

GET/api/v1/earnings/holdsGains bloqués

Recevoir uniquement le nouveau SMS

REST

GET /api/v1/activations/42/sms?after_id=0&limit=100
Authorization: Bearer YOUR_API_KEY

JSON

{
  "session_id": 42,
  "sms": [
    {
      "id": 101,
      "code": "001234",
      "text": "Code : 001234",
      "sender": "Service",
      "received_at": "2026-10-09T12:00:00Z"
    }
  ],
  "next_cursor": 101,
  "has_more": false
}

Enregistrez next_cursor et transmettez-le sous le nom after_id. Si has_more=true, la page suivante peut être lue immédiatement. limit : 1 à 200. Les sessions et SMS sont disponibles uniquement pour le propriétaire.