Iniziare

Documentazione API

Numeri, messaggi e guadagni, direttamente dalla tua app.

GET

Inizia con una richiesta

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

Creare una chiave API nel tuo pannello di controllo, ottenere un numero e verificare i messaggi ogni 20 secondi. Il pagamento viene accreditato quando arriva un SMS con un codice; leggerlo di nuovo non influisce sul tuo saldo.

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

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

Il servizio è vivoNumeri di telefono, SMS e i guadagni sono disponibili; i ritirati sono disponibili in USDT di TRC20I pagamenti sono tra 1 e 45 Giorni di

Avvio rapido · 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}'

Indirizzo interfaccia compatibile alternativo: /handler_api.php. Le integrazioni REST esistenti continuano a funzionare.

REST API

Generatore di richieste

cURL · Go · JS · Python

RichiestaServizio APIPaese APIOperatore operatorCodice proprietario del software refIdempotency-Key

Idempotency-Key: UUID · POST · 8–128

Selezione automatica: più codici nell’ultima ora, poi in 24 ore. Nessun numero: operatore successivo.

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.

Tasto API

La chiave non viene salvata. Questa verifica non assegna numeri.

REST per nuove integrazioni

Servizi e paesi

Scegli un servizio e un paese. Il compenso per SMS dipende dal paese.

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)

Ottieni un numero

REST

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

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

Selezione automatica: più codici nell’ultima ora, poi in 24 ore. Nessun numero: operatore successivo.

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

Il numero è valido per 20 minuti. SMS viene verificato ogni 20 secondi. Puoi annullare immediatamente.

Verifica più numeri

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

Saldo · Bloccato

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 — Disponibile; held_balance — Bloccato. USD · 8

Si possono prelevare solo fondi il cui periodo di blocco è terminato.

Client pronti all’uso

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

Chiave API personale dell’utente.

Scegli un servizio e un paese. Il compenso per SMS dipende dal paese.

Codice	Descrizione
`getNumber / getNumberV2`	Ottieni un numero
`getStatus / getStatusV2`	Ottieni il codice più recente
`setStatus / finishActivation / cancelActivation`	Gestisci sessione
`getPrices / getNumbersStatus`	Verifica la disponibilità
`getRewards (SMScash)`	Ricompensa per SMS
`getServicesList / getServices`	Servizi
`getCountries / getOperators`	Servizi e paesi
`getActiveActivations`	Sessioni
`getBalance`	Saldo dell’utente
`getHoldBalance (SMScash)`	Bloccato

cost = 0 USD · activationCost = 0 USD
reward — Ricompensa per 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'

Risposte

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

Il numero è valido per 20 minuti. SMS viene verificato ogni 20 secondi. Puoi annullare immediatamente.

Autenticazione e tentativi ripetuti

REST: intestazione Authorization: Bearer YOUR_API_KEY. Interfaccia compatibile: parametri api_key e action. Usa HTTPS.

Per gestire le chiavi API, inserisci il tuo account.

∞richieste/min per account

∞sessioni simultanee

La frequenza delle richieste e il numero di numeri di telefono sono illimitati. Non ci sono quote giornaliere o orarie.

Il numero è valido per 20 minuti. SMS viene verificato ogni 20 secondi. Puoi annullare immediatamente.

In REST, un pezzo unico Idempotency-Key è richiesto per l'assegnazione del numero, l'assegnazione ripetuta, retry e le richieste di pagamento. È facoltativo ma consigliato in handler_api.php. Riutilizzare la chiave quando si ritenta una richiesta di rete; utilizzare una nuova chiave per una nuova operazione.

Ambito della chiave API

Puoi associare una chiave a servizi, paesi e fornitori specifici. Gli elenchi vuoti consentono tutte le opzioni disponibili.

JSON

{
  "label": "Il mio software",
  "policy": {
    "services": [
      "go"
    ],
    "countries": [
      86
    ],
    "providers": [
      1
    ]
  }
}

PATCH /api/v1/keys/{id} cambia completamente nome e policy. Il segreto viene mostrato solo al momento della creazione.

10% in totale. 5% + 5% con codice software.

Quando si rilascia un numero, si prega di fornirlo ref proprietario del software. La richiesta è autorizzata dalla chiave dell'utente. Il codice si trova nella sezione "Referrals" e in GET /api/v1/referrals → software_ref.

Richiesta	Chi ha invitato	Software
Senza ref	10%	—
Con ref	5%	5%
Con ref, nessun referrer	—	5%

La piattaforma eroga il bonus senza ridurre il guadagno dell’utente. Il proprietario del software e il referrer possono essere la stessa persona. Un utente non può utilizzare il proprio codice.

I termini vengono fissati quando viene creato un sessione; la lettura di SMS e retry non li cambia. Passare ref ancora per una nuova sessione ripetuta. Nel calcolo del tariffa, un compenso per il utente di USD 0.003 dà USD 0.00015 a ciascuno il proprietario e il referente del software. Il bonus totale è USD 0.00030.

Comandi API

11 metodi in stile XVBC più il tuo saldo SMScash.

GETgetNumberOttieni un numero

Crea una sessione e riserva un numero disponibile per l’utente. La tariffa e i destinatari dei bonus referral vengono fissati all’assegnazione; il compenso viene accreditato alla ricezione di un SMS con un codice.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`service`*	string	Codici di servizio disponibili. La risposta è limitata all'area del tasto API.
`country`*	integer	Prendi ID da getCountries.
`operator`	string	Prendi ID da operators/getOperators (API). `operator=1 · any/0`
`session_duration`	integer	La sessione dura 20 minuti. Passare 20 o omettere questo parametro.
`with_operator`	integer	1 aggiunge l’ID dell’operatore alla risposta; 0 o la sua omissione restituisce tre segmenti.
`ref`	string	Codice pubblico del proprietario del software: 5% per lui e 5% per l'invitante. Senza ref - 10% all'invitante.

*Parametro obbligatorio. In tutte le richieste passa anche action=getNumber.

Richiesta di esempio

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)

Risposte

Numero rilasciato

ACCESS_NUMBER:42:380670000000:1

Nessun numero disponibile

EMPTY_POOL

Selezione automatica: più codici nell’ultima ora, poi in 24 ore. Nessun numero: operatore successivo.
Passa Idempotency-Key: la stessa richiesta con la stessa chiave restituisce la sessione precedente. La modifica dei parametri richiama IDEMPOTENCY_CONFLICT.
Un paese numerico senza pool dà EMPTY_POOL; il formato del paese sbagliato è BAD_COUNTRY.
La chiave di una sessione cancellata rimane utilizzata: riprovare l’allocazione con quella chiave restituisce SESSION_CLOSED e non genera un altro numero.
L’esito dell’assegnazione non è confermato. Il tentativo automatico è disattivato per evitare di assegnare un secondo numero.

GETgetNumbersStatusVerifica la disponibilità

Quantità di numeri di telefono disponibili per servizio e paese.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`country`*	integer	Prendi ID da getCountries.

*Parametro obbligatorio. In tutte le richieste passa anche action=getNumbersStatus.

Richiesta di esempio

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

Risposte

Numeri disponibili

{
  "go_0": 0
}

Il suffisso _0 indica una scelta senza un operatore specifico.
La disponibilità riguarda l’intero insieme del fornitore. Il canale scelto viene verificato quando si assegna un numero.

GETgetStatusOttieni il codice più recente

Facile richiesta dello stato della sessione e dell'ultimo codice SMS. Gli zeri iniziali nel codice vengono conservati.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`id`*	integer	ID della tua sessione, ricevuto al momento dell'emissione del numero.

*Parametro obbligatorio. In tutte le richieste passa anche action=getStatus.

Richiesta di esempio

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)

Risposte

In attesa

STATUS_WAIT_CODE

Codice ricevuto

STATUS_OK:001234

Cancellazione o scadenza

STATUS_CANCEL

Non trovato

NO_ACTIVATION

Rilasciare un sondaggio ogni 20 secondi. Leggendo un messaggio di nuovo non genera un altro pagamento.
Dopo retry non viene restituito il vecchio codice: getStatus attende il successivo SMS.
Dopo che un numero senza SMS viene eliminato, getStatus e getSms restituiscono STATUS_CANCEL; getSmsFull restituisce lo stato chiuso, un telefono vuoto e una lista di SMS vuota. REST /activations/{id} e /sms restituiscono 404 NO_ACTIVATION.

GETsetStatusGestisci sessione

Termina, annulla o riprende l’attesa per SMS. La scadenza della sessione rimane invariata.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`id`*	integer	ID della tua sessione, ricevuto al momento dell'emissione del numero.
`status`*	integer	3 — aspettare il prossimo codice senza estendere la sessione; 6 — completare dopo SMS; 8 — annullare immediatamente.

*Parametro obbligatorio. In tutte le richieste passa anche action=setStatus.

Richiesta di esempio

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)

Risposte

In attesa di SMS

ACCESS_RETRY_GET

Completato

ACCESS_ACTIVATION

Annullato

ACCESS_CANCEL

Riprova: attenda il prossimo codice entro i 20 minuti originali. I tempi di problema e scadenza non cambiano.
Per stato=3 utilizzare Idempotency-Key: ripetere la richiesta non azzererà il nuovo codice già ricevuto. La cronologia di SMS rimane disponibile.
L’annullamento non sottrae i compensi già guadagnati.
Solo i numeri con codice SMS vengono conservati nella storia. I numeri annullati e scaduti senza codice vengono cancellati.

GETgetRepeatNumberEmetti di nuovo lo stesso numero

Apre una nuova sessione con un numero specifico dalla tua cronologia. Puoi selezionare un altro servizio disponibile nello stesso Paese.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`number`*	string	Il tuo vecchio numero. Sono consentiti solo numeri e un + iniziale facoltativo.
`service`*	string	Codici di servizio disponibili. La risposta è limitata all'area del tasto API.
`session_duration`	integer	La sessione dura 20 minuti. Passare 20 o omettere questo parametro.
`with_operator`	integer	1 aggiunge l’ID dell’operatore alla risposta; 0 o la sua omissione restituisce tre segmenti.
`ref`	string	Codice pubblico del proprietario del software: 5% per lui e 5% per l'invitante. Senza ref - 10% all'invitante.
`operator`	string	Prendi ID da operators/getOperators (API). `operator=1 · any/0`

*Parametro obbligatorio. In tutte le richieste passa anche action=getRepeatNumber.

Richiesta di esempio

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)

Risposte

Nuova sessione

ACCESS_NUMBER:43:380670000000

Il numero è ancora occupato

NUMBER_IN_USE

Innanzitutto, termina o annulla la sessione corrente. Se il numero è occupato la riemissione non viene effettuata.
La nuova sessione riceve un nuovo ID e la tariffa attuale. I vecchi SMS non vengono copiati al suo interno. ref viene impostato nuovamente.
SMScash consente di ripetere solo i numeri dalla cronologia di questo account. Il paese è identificato da un numero.
La chiave di una sessione cancellata rimane utilizzata: riprovare l’allocazione con quella chiave restituisce SESSION_CLOSED e non genera un altro numero.

GETgetSmsFullOttieni SMS come JSON

Storico strutturato di tutti i messaggi con ID, mittente, codice, testo e paese, dati servizio e fornitore.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`id`*	integer	ID della tua sessione, ricevuto al momento dell'emissione del numero.

*Parametro obbligatorio. In tutte le richieste passa anche action=getSmsFull.

Richiesta di esempio

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

Risposte

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

Formato preferito per l'integrazione. Ricorda che sms[].id elabora solo i nuovi messaggi.
Stato numerico SMScash: 1 - attivo, 6 - completato, 8 - annullato o scaduto. status_name distingue tra in attesa, ricevuto, terminato, annullato, scaduto.
I codici ricevuti rimangono disponibili dopo la chiusura della sessione. Per grandi volumi, utilizzare REST /activations/{id}/sms con after_id.
Dopo che un numero senza SMS viene eliminato, getStatus e getSms restituiscono STATUS_CANCEL; getSmsFull restituisce lo stato chiuso, un telefono vuoto e una lista di SMS vuota. REST /activations/{id} e /sms restituiscono 404 NO_ACTIVATION.

GETgetSmsOttieni SMS come stringa di testo

Restituisce l'intera cronologia SMS in formato stringa per i client esistenti.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`id`*	integer	ID della tua sessione, ricevuto al momento dell'emissione del numero.

*Parametro obbligatorio. In tutte le richieste passa anche action=getSms.

Richiesta di esempio

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)

Risposte

Messaggio

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

In attesa

STATUS_WAIT_CODE

Cancellazione o scadenza

STATUS_CANCEL

Formato del messaggio: ora|codice|testo. Più messaggi sono separati da due punti.
Il testo SMS stesso può contenere due punti e barre verticali. Per un'analisi affidabile, utilizzare getSmsFull.

GETgetServicesServizi

Codici di servizio disponibili. La risposta è limitata all'area del tasto API.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`country`	integer	Prendi ID da getCountries.

*Parametro obbligatorio. In tutte le richieste passa anche action=getServices.

Richiesta di esempio

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

Risposte

Servizi

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

Il percorso di servizio è condiviso tra i fornitori. La disponibilità del numero viene verificata separatamente.

GETgetCountriesPaesi

ID, nomi e codici di chiamata per i paesi nel canale selezionato.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.

*Parametro obbligatorio. In tutte le richieste passa anche action=getCountries.

Richiesta di esempio

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

Risposte

Paesi

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

GETgetOperatorsOperatori

Operatori disponibili: ID API, nome e periodo di trattenuta.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`country`	integer	Prendi ID da getCountries.
`operator`	string	Prendi ID da operators/getOperators (API). `operator=1 · any/0`

*Parametro obbligatorio. In tutte le richieste passa anche action=getOperators.

Richiesta di esempio

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

Risposte

Operatori

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

Prendi ID da operators/getOperators (API).

GETgetRewardsRicompensa per SMS

I tassi dipendono dal paese. Tutti i valori indicati nella tabella sono per un pagamento SMS.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.
`country`	integer	Prendi ID da getCountries.
`service`	string	Codici di servizio disponibili. La risposta è limitata all'area del tasto API.
`operator`	string	Prendi ID da operators/getOperators (API). `operator=1 · any/0`

*Parametro obbligatorio. In tutte le richieste passa anche action=getRewards.

Richiesta di esempio

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

Risposte

JSON

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

{}

{}

USDI monti tariffali vengono restituiti come stringhe decimali esatte con 8 cifre decimali:
Provider abilitati disponibili per la tua chiave.
country ID → service code → operator ID → reward (USD)

GETgetBalanceSaldo dell’utente

Aggiunta SMScash: saldo disponibile tenendo conto di ratei, bonus di riferimento e richieste di pagamento.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.

*Parametro obbligatorio. In tutte le richieste passa anche action=getBalance.

Richiesta di esempio

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)

Risposte

Saldo

ACCESS_BALANCE:0.00

getBalance restituisce il saldo disponibile in USD con fino a 8 decimali.
Si possono prelevare solo fondi il cui periodo di blocco è terminato.

GETgetHoldBalanceBloccato

Alla ricezione di un SMS, i guadagni vengono trattenuti per il periodo stabilito dal fornitore. Alla data indicata, l’importo diventa automaticamente disponibile per il prelievo.

Parametri

Parametro	Digitare	Descrizione
`api_key`*	string	Chiave API personale dell’utente.

*Parametro obbligatorio. In tutte le richieste passa anche action=getHoldBalance.

Richiesta di esempio

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)

Risposte

Bloccato

ACCESS_HOLD_BALANCE:34.50000001

SMScash · getHoldBalance · USD · 8
Si possono prelevare solo fondi il cui periodo di blocco è terminato.

Codici di risposta e richieste ripetute

In handler_api.php i risultati aziendali di solito arrivano con HTTP 200. Controlla il corpo del testo. Directory e getSmsFull restituiscono JSON in caso di successo; gli errori sono sempre testo.

Codice	HTTP	Causa e passo successivo
`TARIFF_NOT_CONFIGURED`	200	I tassi non sono ancora fissatiL’assegnazione dei numeri inizierà non appena le ricompense SMS saranno configurate.
`COUNTRY_BLOCKED`	200	L’allocazione dei numeri per questo paese è bloccata.Scegli un altro paese.
`BAD_SERVICE`	200	L’assegnazione di numeri per questo servizio è bloccata.Scegli un altro servizio.
`PROVIDER_NOT_READY`	200	L’allocazione dei numeri è temporaneamente inesistenteAggiorna i cataloghi API.
`BAD_KEY`	400	Nessun api_key o formato non valido.Controllare la chiave nella richiesta.
`INVALID_API_KEY`	401	La chiave è sconosciuta, revocata o l'account è disabilitato.Crea una chiave API valida.
`BAD_COUNTRY`	400	il paese manca o non è un numero positivo.Prendi ID da getCountries.
`BAD_SESSION_DURATION`	400	I numeri di telefono vengono rilasciati per esattamente 20 minuti.session_duration corretto.
`BAD_REQUEST`	400	Parametro non valido o Idempotency-Key.Per favore correggi la tua richiesta.
`BAD_SERVICE / BAD_OPERATOR / INVALID_PROVIDER`	200	Elemento della directory sconosciuto o disabilitato.Aggiorna i cataloghi API.
`BAD_NUMBER`	200	Formato numero errato.Fornisci il numero in cifre.
`BAD_ACTION / BAD_STATUS`	200	Comando, ID o operazione sconosciuta.Controlla le impostazioni.
`EMPTY_POOL`	200	Nessun numero di telefono corrispondente è attualmente disponibile.Ripetere dopo 10-30 secondi o modificare i filtri.
`NUMBER_IN_USE`	200	Un numero specifico è occupato da una sessione attiva.Termina la sessione o seleziona un altro numero.
`NO_ACTIVATION`	200	La sessione o il numero precedente non appartengono al tuo account.Controllare ID e la chiave.
`SESSION_CLOSED / SMS_REQUIRED`	200	La transizione di stato non è attualmente disponibile.Controlla le condizioni e la disponibilità di SMS.
`SCOPE_BLOCKED`	200	Il servizio, il paese o il fornitore non sono autorizzati per la chiave.Aggiorna l'ambito della chiave API.
`IDEMPOTENCY_CONFLICT`	200	Questa chiave di query è già associata ad altri parametri.Per una nuova operazione, crea un altro Idempotency-Key.
`BAD_REF / SELF_REF`	400	Il codice del software è sconosciuto, disabilitato o appartiene allo stesso utente.Trasmetti il codice del proprietario del software.
`INTERNAL_ERROR`	500	Errore temporaneo del server o del fornitore.Ripeti con un ritardo e lo stesso Idempotency-Key.
`ALLOCATION_PENDING`	200	L’assegnazione del numero è già in corso. Riprova con lo stesso Idempotency-Key.L’assegnazione del numero è già in corso. Riprova con lo stesso Idempotency-Key.
`ALLOCATION_UNCERTAIN`	200	L’esito dell’assegnazione non è confermato. Il tentativo automatico è disattivato per evitare di assegnare un secondo numero.L’esito dell’assegnazione non è confermato. Il tentativo automatico è disattivato per evitare di assegnare un secondo numero.

REST restituisce un oggetto {"error":{"code":"…","message":"…"}} e gli stati HTTP regolari 400/401/403/404/409/503.

JSON

{
  "error": {
    "code": "BAD_REQUEST",
    "message": "Controlla i campi della richiesta.",
    "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 per nuove integrazioni

USDI monti tariffali vengono restituiti come stringhe decimali esatte con 8 cifre decimali: 0.00300000 USD.

La valuta del saldo è USD. Gli schemi di richiesta e risposta sono disponibili in OpenAPI.

Prelievo in USDT · TRC20I pagamenti richiedono da 1 a 45 giorni. La commissione di prelievo è di 4 $. Viene detratta dall’importo richiesto. Alla ricezione di un SMS, i guadagni vengono trattenuti per il periodo stabilito dal fornitore. Alla data indicata, l’importo diventa automaticamente disponibile per il prelievo. Si possono prelevare solo fondi il cui periodo di blocco è terminato.

GET/api/v1/catalogServizi e paesi

GET/api/v1/tariffsSMS tassi di ricompensa per paese

GET/api/v1/offersTariffe e premi

GET/api/v1/servicesDirettorio

GET/api/v1/countriesDirettorio

GET/api/v1/operatorsDirettorio

GET/api/v1/availability?country=1Disponibilità del numero

POST/api/v1/activationsNuova sessione

GET/api/v1/activations/batch?ids=42,43Verifica più numeri

GET/api/v1/activationsUltime 200 sessioni: scope=history, in attesa o tutte

GET/api/v1/activations/{id}Sessione e messaggi

GET/api/v1/activations/{id}/sms?after_id=0&limit=100Nuovo SMS con cursore

POST/api/v1/activations/{id}/retryIn attesa di SMS

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

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

POST/api/v1/activations/repeatRistampa del numero

GET/api/v1/keysTasti API

POST/api/v1/keysCrea una chiave

PATCH/api/v1/keys/{id}Cambia nome o policy

DELETE/api/v1/keys/{id}Revoca chiave

GET/api/v1/referralsCodice di riferimento e guadagni

GET/api/v1/summaryBilancio e sintesi

GET/api/v1/balanceBloccato

GET/api/v1/ledgerRegistro dei guadagni

GET/api/v1/withdrawalsRichieste di pagamento

POST/api/v1/withdrawalsCrea una richiesta

GET/api/v1/statisticsStatistiche generali

GET/api/v1/earnings/holdsGuadagni bloccati

Ricevo solo il nuovo 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": "Codice: 001234",
      "sender": "Service",
      "received_at": "2026-10-09T12:00:00Z"
    }
  ],
  "next_cursor": 101,
  "has_more": false
}

Salva next_cursor e trasmettelo come after_id. Se has_more=true, la pagina successiva può essere letta immediatamente. limit: 1–200. Sessioni e SMS sono disponibili solo per il proprietario.