Hub di migrazione SMS-Activate 2026: lista di controllo per sviluppatori, mappatura API e confronto rimborsi

If you are still carrying handler_api.php calls in your repo pointed at sms-activate.org, this is the hub you open at 9pm on a Friday and close with a working integration before midnight. Real endpoint mapping, real code diffs, refund policy comparison, and the gotchas that will bite you between the line you change and the alert that wakes you up on Monday morning.

Perché esiste questo playbook

La maggior parte dei post "SMS-Activate è morto, ecco una lista di alternative" manca della parte che brucia davvero le ore di sviluppo: il codice. Registrarsi per un nuovo provider richiede cinque minuti. Riscrivere un'integrazione che è stata eseguita silenziosamente in produzione per anni, con casi d'angolo non testati e un tracker dei costi allegato, richiede più tempo di quanto pensi.

Dopo aver spedito il nostro livello di compatibilità a gennaio 2026, abbiamo iniziato a ricevere le stesse tre domande da ogni team che l'ha provato:

1. Quali endpoint si mappano in modo pulito e quali richiedono modifiche manuali?
2. Come posso mantenere funzionante il mio monitoraggio dei costi e il flusso di rimborso senza una riscrittura?
3. Cosa si rompe silenziosamente e compare una settimana dopo come sorpresa di fatturazione?

Questo playbook risponde a queste tre domande in ordine e fornisce codice pronto per la copia e la verifica prima dell'esecuzione.

Il riepilogo di 48 ore: cosa è realmente accaduto

SMS-Activate è andato in crash il 29 dicembre 2025. Non c'era un banner di manutenzione programmata, nessun tool di migrazione e nessun avviso pubblico. Gli utenti che hanno provato a loggarsi hanno incontrato una pagina singola che diceva che il servizio era chiuso permanentemente. L'API ha restituito reset di connessione su ogni endpoint entro poche ore.

Sono accadute tre cose velocemente:

• I saldi del dashboard sono diventati irraggiungibili. I rapporti sul subreddit r/sms e sui canali Telegram ufficiali hanno descritto saldi da $20 a diverse migliaia di dollari congelati senza percorso di recupero.
• Le integrazioni in esecuzione sono state rotte. Qualsiasi servizio che eseguiva il polling handler_api.php ha iniziato a ricevere errori di connessione HTTP, che nella maggior parte dei tracker di bug significano "interruttore di circuito scattato, avvisa il team".
• La finestra di migrazione si è chiusa in giorni, non settimane. Entro 72 ore ogni provider rimanente aveva una coda. 5sim, SMSPVA e SMS-MAN hanno tutti riconosciuto la tensione di capacità. VerifySMS è rimasto stabile perché eravamo il più piccolo del gruppo e avevamo una riserva di capacità, ma è stato davvero vicino.

Le conseguenze sono ancora in corso. A partire da aprile 2026 ci sono casi di piccola causa attivi in Russia e almeno due cause legali coordinate dalla comunità che cercano di recuperare i saldi congelati. Nessuno di questi aiuta il tuo codice, motivo per cui ci concentreremo sulla parte che puoi effettivamente risolvere.

Parte 1: Mappa di deprecazione dell'API

SMS-Activate ha spedito un singolo endpoint pubblico su https://sms-activate.org/stubs/handler_api.php. Ogni azione era un parametro della stringa di query su quell'URL. La tabella seguente mappa ogni azione principale sul suo equivalente VerifySMS. Il livello di compatibilità su https://api.verifysms.app/compat/handler_api.php accetta esattamente la stessa forma di stringa di query.

Una manciata di azioni SMS-Activate meno utilizzate non si mappano uno a uno. getRentServicesAndCountries e l'API di affitto a lungo termine erano specifici di SMS-Activate e non hanno un livello di compatibilità. Se la tua integrazione utilizzava quelli, dovresti passare all'endpoint di affitto a lungo termine nativo VerifySMS su POST /v1/rentals/long, che è documentato separatamente.

Parte 2: Esercitazioni di migrazione del codice

I seguenti snippet sono esattamente la forma che ho testato contro il nostro ambiente di staging a gennaio. Li ho mantenuti deliberatamente noiosi in modo che tu possa leggerli contro il tuo codice senza cambiare contesto.

Python (richieste)

L'unica modifica richiesta è l'URL di base. Se hai già avvolto l'API in un piccolo modulo client, la diff è una singola riga.

import os
import requests

# PRIMA
# BASE_URL = "https://sms-activate.org/stubs/handler_api.php"
# DOPO
BASE_URL = "https://api.verifysms.app/compat/handler_api.php"
API_KEY = os.environ["SMS_API_KEY"]

def get_number(service: str, country: int) -> tuple[str, str]:
    resp = requests.get(BASE_URL, params={
        "api_key": API_KEY,
        "action": "getNumber",
        "service": service,
        "country": country,
    }, timeout=30)
    resp.raise_for_status()
    # ACCESS_NUMBER:12345:+441234567890
    status, rental_id, phone = resp.text.split(":", 2)
    if status != "ACCESS_NUMBER":
        raise RuntimeError(f"risposta inaspettata: {resp.text}")
    return rental_id, phone

def wait_for_code(rental_id: str, deadline_seconds: int = 180) -> str:
    import time
    start = time.monotonic()
    while time.monotonic() - start < deadline_seconds:
        resp = requests.get(BASE_URL, params={
            "api_key": API_KEY,
            "action": "getStatus",
            "id": rental_id,
        }, timeout=15).text
        if resp.startswith("STATUS_OK:"):
            return resp.split(":", 1)[1]
        time.sleep(4)
    # Segna come non utilizzato in modo da ottenere il rimborso
    requests.get(BASE_URL, params={
        "api_key": API_KEY,
        "action": "setStatus",
        "status": 8,
        "id": rental_id,
    }, timeout=15)
    raise TimeoutError(f"nessun codice dopo {deadline_seconds}s")

Node.js (axios)

import axios from "axios";

// PRIMA
// const BASE_URL = "https://sms-activate.org/stubs/handler_api.php";
// DOPO
const BASE_URL = "https://api.verifysms.app/compat/handler_api.php";
const API_KEY = process.env.SMS_API_KEY;

export async function getNumber(service, country) {
  const { data } = await axios.get(BASE_URL, {
    params: { api_key: API_KEY, action: "getNumber", service, country },
    timeout: 30_000,
  });
  const [status, rentalId, phone] = data.split(":");
  if (status !== "ACCESS_NUMBER") {
    throw new Error(`risposta inaspettata: ${data}`);
  }
  return { rentalId, phone };
}

export async function waitForCode(rentalId, deadlineMs = 180_000) {
  const start = Date.now();
  while (Date.now() - start < deadlineMs) {
    const { data } = await axios.get(BASE_URL, {
      params: { api_key: API_KEY, action: "getStatus", id: rentalId },
      timeout: 15_000,
    });
    if (data.startsWith("STATUS_OK:")) return data.split(":")[1];
    await new Promise((r) => setTimeout(r, 4000));
  }
  await axios.get(BASE_URL, {
    params: { api_key: API_KEY, action: "setStatus", status: 8, id: rentalId },
    timeout: 15_000,
  });
  throw new Error(`nessun codice dopo ${deadlineMs}ms`);
}

PHP (curl)

<?php
// PRIMA
// const BASE_URL = "https://sms-activate.org/stubs/handler_api.php";
// DOPO
const BASE_URL = "https://api.verifysms.app/compat/handler_api.php";

function sms_call(array $params): string {
    $params["api_key"] = getenv("SMS_API_KEY");
    $url = BASE_URL . "?" . http_build_query($params);
    $ch  = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    $body = curl_exec($ch);
    curl_close($ch);
    return $body;
}

function get_number(string $service, int $country): array {
    $resp = sms_call(["action" => "getNumber", "service" => $service, "country" => $country]);
    [$status, $id, $phone] = explode(":", $resp, 3);
    if ($status !== "ACCESS_NUMBER") {
        throw new RuntimeException("inaspettato: $resp");
    }
    return ["id" => $id, "phone" => $phone];
}

Go (net/http)

package sms

import (
    "errors"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strings"
    "time"
)

// PRIMA
// const baseURL = "https://sms-activate.org/stubs/handler_api.php"
// DOPO
const baseURL = "https://api.verifysms.app/compat/handler_api.php"

func call(params url.Values) (string, error) {
    params.Set("api_key", os.Getenv("SMS_API_KEY"))
    req, _ := http.NewRequest("GET", baseURL+"?"+params.Encode(), nil)
    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    return string(body), nil
}

func GetNumber(service string, country int) (id, phone string, err error) {
    body, err := call(url.Values{
        "action":  {"getNumber"},
        "service": {service},
        "country": {fmt.Sprint(country)},
    })
    if err != nil {
        return "", "", err
    }
    parts := strings.SplitN(body, ":", 3)
    if len(parts) != 3 || parts[0] != "ACCESS_NUMBER" {
        return "", "", errors.New("inaspettato: " + body)
    }
    return parts[1], parts[2], nil
}

L'esempio Go è scritto deliberatamente senza alcun client di terze parti in modo che tu possa inserirlo in un servizio minimo senza aggiungere dipendenze. Lo stesso modello vale per ogni altra lingua: scambia l'URL, mantieni il resto e lascia che la tua gestione degli errori esistente si propaghi.

Parte 3: Insidie che ti bruceranno

Questi sono i posti dove il livello di compatibilità è fedele alle stranezze di SMS-Activate ma le stranezze stesse ti sorprenderanno se non hai toccato questo codice da un po'.

Gli ID paese non sono codici ISO

SMS-Activate ha numerato i paesi in ordine proprio: la Russia era 0, gli Stati Uniti erano 187, l'Indonesia era 6 e così via. Se la tua integrazione ha questi numeri magici codificati, funzionano ancora sul livello di compatibilità. Se stai scrivendo nuovo codice, preferisci la forma ISO-3166 alpha-2 (RU, US, ID) che il livello di compatibilità accetta anche. Non mescolare entrambi gli stili nello stesso sito di chiamata, perché la futura debug sarà dolorosa.

Codice di stato 3 contro 6

L'azione setStatus codice 3 significava "richiedi un altro SMS" nel mondo di SMS-Activate e il codice 6 significava "accetta il codice come valido". Questi due codici sono facili da scambiare in fretta e hanno esiti di fatturazione opposti: 3 ti tiene fatturato, 6 conferma la verifica riuscita. Il livello di compatibilità si comporta nello stesso modo. Cerca nel tuo codice setStatus e assicurati che il ramo che prende il codice 6 funzioni solo dopo esserti assicurato che la verifica sia riuscita.

Timeout e interruttori di circuito

SMS-Activate sotto carico a volte restituiva un 200 con un corpo vuoto invece di un errore HTTP. I client difensivi avvolgono la chiamata in un timeout e trattano il corpo vuoto come un segnale di ritentativo. VerifySMS non restituisce mai un corpo vuoto sul livello di compatibilità. Se il tuo client tratta ancora il vuoto come un ritentativo, brucerà il budget su una rete instabile perché il ritentativo colpirà un ID di affitto diverso. Il modello più sicuro è controllare i prefissi di risposta noti (ACCESS_, STATUS_, BAD_) e trattare qualsiasi altra cosa come un errore duro, non transitorio.

I limiti di velocità si spostano da per chiave a per IP

I limiti di velocità di SMS-Activate erano indicizzati sulla chiave API. I limiti di velocità di VerifySMS sono indicizzati sulla combinazione di chiave API e indirizzo IP di origine, perché vediamo molta abuso da parte degli script di scraping che condividono una chiave tra una botnet. Per il normale traffico di produzione da un singolo server o da un pool bilanciato, questo è invisibile. Se esegui lavori CI distribuiti che condividono tutti una chiave di test, potresti vedere un 429 la prima volta che la flotta si scalda insieme. La soluzione è lasciare che il canarino funzioni da un nodo per un giorno prima di estenderlo.

La tempistica dei rimborsi sembra istantanea perché lo è

Questo non è un trucco tanto quanto una piacevole sorpresa. Dove i rimborsi di SMS-Activate richiedevano alcune ore per apparire nel tuo saldo, i rimborsi di VerifySMS appaiono entro 60 secondi. Se il tuo tracker dei costi legge il saldo su una pianificazione, registrerà il rimborso come un credito che il vecchio sistema avrebbe perso. Le dashboard di riconciliazione a volte segnalano questo come un'anomalia il primo giorno.

Parte 4: Controllo di realtà del confronto dei prezzi

Prima della chiusura, SMS-Activate era il limite del mercato. I numeri russi costavano $0,03 a $0,05 per verifica e gli acquirenti a grande volume pagavano ancora meno. Quel limite è scomparso. Ecco dove si trovano i fornitori rimanenti ad aprile 2026 per i servizi più comuni, tratti dalla pagina dei prezzi pubblici di ciascun fornitore il 7 aprile 2026:

Il modello è semplice: 5sim e SMS-MAN vincono sui prezzi più bassi per la Russia, TextVerified è il livello premium statunitense e VerifySMS si trova nel mezzo con una base di $0,10 per tutto, tranne che per i numeri non-VoIP statunitensi più costosi. Se il tuo budget era sintonizzato sui prezzi minimi di SMS-Activate, aspettati di pagare due a cinque volte di più per verifica, indipendentemente da quale sostituto scegli.

Due note su questa tabella. Innanzitutto, ogni fornitore (compreso VerifySMS) aumenta e diminuisce i prezzi individuali dei paesi in risposta ai costi dei vettori, quindi conferma il prezzo corrente nel tuo dashboard prima di impegnare un budget. In secondo luogo, il prezzo effettivo per verifica riuscita dipende dal rapporto di rimborso. Un fornitore con un prezzo di $0,08 e un tasso di successo del 70% costa più di un fornitore con un prezzo di $0,10 e un tasso di successo del 90%.

Parte 5: Lista di controllo per la migrazione in 10 passaggi

Questa è la sequenza effettiva che abbiamo fatto seguire ai nostri utenti a gennaio. Si presuppone uno sviluppatore con accesso al repository, un servizio di produzione e un ambiente di staging. Scala le percentuali del canarino se stai eseguendo più servizi o un monorepo.

1. Inventaria ogni sito di chiamata. Esegui git grep -n 'sms-activate\.org\|handler_api\.php\|getNumber\|setStatus' e elenca ogni file che colpisce la vecchia API. Se ne trovi più di una dozzina, scegli un modulo wrapper e centralizza le chiamate prima di migrare.
2. Ottieni una chiave API VerifySMS. Iscriviti, aggiungi una piccola quantità di saldo e genera una chiave con ambito per l'ambiente di staging. Tieni la chiave di produzione fuori dal repository.
3. Cambia l'URL di base. Sostituisci l'host SMS-Activate con api.verifysms.app/compat/handler_api.php. Non modificare la stringa di query. Committa questo da solo in modo che il diff sia pulito.
4. Esegui i test esistenti. Se i test colpiscono l'API reale, indirizzali verso l'ambiente di staging e guarda le discrepanze di forma. Se simulano l'API, eseguili anche contro il punto finale di staging attivo in modo da catturare la deriva del contratto.
5. Riconferma gli ID paese. Sfoglia il tuo codice per le costanti di paese. Se stai utilizzando gli ID numerici legacy, funzionano ancora. Se hai la possibilità, sostituiscili con codici ISO-3166 perché il prossimo sviluppatore che toccherà questo file ti ringrazierà.
6. Collega le richieste di rimborso. Conferma che il tuo percorso di timeout chiami setStatus con status=8. Senza questo, riceverai ancora rimborsi (noi rimborsiamo automaticamente i leasing scaduti) ma il tuo tracker dei costi sarà in ritardo rispetto alla realtà.
7. Aggiorna il tuo tracker dei costi. Leggi il costo dalla risposta dell'intestazione X-VerifySMS-Cost invece di estrarlo dalla tabella dei prezzi. Questo singolo cambio rende il tuo dashboard finanziario preciso al centesimo.
8. Monitoraggio. Aggiungi avvisi per il tasso di successo, la latenza p95 e il rapporto di rimborso contro la tua linea di base esistente. Scegli soglie che puoi difendere, non quelle che pensi saranno "sufficienti".
9. Canarino al 5 percento per 24 ore. Instrada una piccola fetta del traffico di produzione attraverso il nuovo punto finale. Guarda il dashboard, non solo gli avvisi.
10. Taglia il resto. Una volta che la finestra del canarino è pulita, sposta il 95 percento rimanente e lascia il vecchio codice del client commentato (non cancellato) per un ciclo di rilascio in modo da avere un rapido rollback.

Cancella il vecchio codice nel rilascio successivo. Non lasciare siti di chiamata morti in giro per più di una settimana perché la prossima persona che tocca il modulo li incollerà di nuovo in una nuova integrazione per errore.

Domande frequenti

Il livello di compatibilità SMS-Activate è un'API reale o solo un finto?

È un punto finale reale a api.verifysms.app/compat/handler_api.php che accetta ogni azione principale dalla documentazione pubblica di SMS-Activate: getBalance, getNumber, getStatus, setStatus, getPrices e getCountries. Le richieste sono proxy verso la nostra API nativa sotto il cofano, quindi ottieni i prezzi di VerifySMS, la copertura e il comportamento di rimborso senza modifiche al codice dal tuo lato.

La mia vecchia chiave API funzionerà?

No. Le chiavi API di SMS-Activate hanno smesso di autenticare il giorno in cui il servizio è stato chiuso. Hai bisogno di una nuova chiave da VerifySMS. Iscriviti, aggiungi una piccola quantità di saldo e genera una chiave dal dashboard. Il formato della chiave è identico in lunghezza quindi puoi incollarla nella stessa variabile di ambiente.

Come funzionano i rimborsi rispetto a SMS-Activate?

SMS-Activate richiedeva di chiamare setStatus con codice di stato 8 entro 20 minuti per contrassegnare un numero come inutilizzato e i rimborsi venivano elaborati manualmente entro poche ore. VerifySMS accetta la stessa chiamata setStatus e rimborsa l'importo completo sul tuo saldo entro 60 secondi. Se dimentichi di chiamare setStatus del tutto, il nostro sistema rimborsa automaticamente qualsiasi numero che non abbia ricevuto un SMS dopo la scadenza della finestra di leasing.

Quali paesi sono supportati?

VerifySMS copre oltre 200 paesi. Tutti i paesi offerti da SMS-Activate sono disponibili su VerifySMS, inclusi Russia, Indonesia, Vietnam, Nigeria e Stati Uniti. Puoi mantenere la tua mappatura ID paese esistente o migrare verso codici ISO-3166 alpha-2 quando vuoi.

I prezzi sono gli stessi?

No. I prezzi minimi di mercato di SMS-Activate di $0,03 a $0,05 per verifica per i numeri russi sono scomparsi dal mercato aperto. I prezzi di mercato attuali vanno da $0,10 per servizi comuni a $0,25 per numeri non-VoIP statunitensi su piattaforme più strette. VerifySMS addebita $0,10 come base e pubblica i prezzi per paese sul dashboard.

Devo cambiare la mia logica di polling?

No. La chiamata getStatus restituisce STATUS_WAIT_CODE e STATUS_OK nello stesso formato utilizzato da SMS-Activate. Gli intervalli di polling di 3 a 5 secondi funzionano ancora. L'unico nuovo comportamento è che VerifySMS espone anche un URL di webhook nel dashboard, quindi puoi smettere di eseguire il polling se preferisci un flusso basato su eventi.

Cosa succede se il livello di compatibilità viene mai deprecato?

Il livello di compatibilità è considerato un'interfaccia pubblica permanente. Se mai cambiamo il suo comportamento, pubblicheremo una finestra di deprecazione minima di sei mesi con una nota di migrazione completa. La API JSON nativa di VerifySMS è anche documentata, quindi puoi migrare fuori dal livello di compatibilità al tuo ritmo quando ha senso.

Come posso testare senza spendere soldi?

Il dashboard di VerifySMS espone una modalità sandbox che restituisce numeri di telefono simulati e codici SMS preparati senza addebitare il tuo saldo. Attiva il flag sandbox nel dashboard o invia l'intestazione X-Sandbox-Mode con qualsiasi richiesta per esercitare i tuoi percorsi di codice prima di andare live.

Posso migrare da altri servizi?

Sì. Questa guida è scritta intorno all'API di SMS-Activate perché è dove vive la maggior parte del codice bloccato, ma la stessa lista di controllo si applica alle migrazioni da 5sim, SMS-MAN o qualsiasi altro servizio compatibile con handler_api. Il livello di compatibilità riconosce i parametri handler_api.php indipendentemente dal servizio che stavi chiamando in precedenza.

Quanto tempo ci vuole per una migrazione reale?

Per un'integrazione di servizio singolo con poche decine di siti di chiamata, pianifica due a quattro ore di lavoro concentrato, più una finestra di canarino di 24 ore prima di tagliare il traffico completo. Le migrazioni di servizi multipli più grandi con gestione degli errori personalizzata, analisi e ripetizioni possono durare più tempo ma di solito finiscono entro un singolo giorno lavorativo.

Perdo i miei dati storici?

La storia di verifica di SMS-Activate è andata offline quando il servizio è stato chiuso e non è recuperabile. VerifySMS mantiene un registro di audit completo di ogni tentativo di verifica sul tuo account per 12 mesi, accessibile dal dashboard e tramite l'estensione /compat/handler_api.php?action=getHistory.

Ciò influisce sulla mia posizione di conformità o GDPR?

VerifySMS è registrato nel Regno Unito e segue il GDPR del Regno Unito. Pubblichiamo la nostra politica di conservazione dei dati, i sub-processori e il DPA nella pagina della privacy. Se la tua configurazione precedente richiedeva un DPA con SMS-Activate, contattaci e contrassegneremo lo stesso accordo entro un giorno lavorativo.

Passaggi successivi

Se hai letto fino a qui, hai già i pezzi che ti servono. Inizia con il passaggio di inventario, ottieni lo scambio di URL di base davanti a un collega per la revisione e esegui il canarino durante la notte. La guida è piccola di proposito; la parte difficile è la disciplina di fermarsi dopo la finestra del canarino invece di tagliare tutto in un solo commit.

Lettura correlata sul resto del sito:

• Stato della verifica SMS 2026 — benchmark indipendente completo di 8 servizi con dati su prezzi, traffico e politica di rimborso.
• Migliori Alternative SMS-Activate 2026 — Guida Completa — guida non tecnica alle opzioni di sostituzione.
• VerifySMS vs SMS-Activate — Confronto completo — confronto fianco a fianco per team ancora in valutazione.
• Guida all'integrazione dell'API di verifica SMS — percorso dettagliato dell'API JSON nativa di VerifySMS quando sei pronto a passare dal livello di compatibilità.

Next steps

If you have read this far, you already have the pieces you need. Start with the inventory step, get the base URL swap in front of a teammate for review, and run the canary overnight. The playbook is small on purpose; the hard part is the discipline to stop after the canary window instead of cutting everything over in one commit.

Related reading on the rest of the site:

• State of SMS Verification 2026 — full independent benchmark of 8 services with pricing, traffic, and refund policy data.
• Migliori Alternative SMS-Activate 2026 — Guida Completa — non-developer guide to the replacement options.
• VerifySMS vs SMS-Activate — Confronto completo — side-by-side comparison for teams still evaluating.
• SMS Verification API Integration Guide — native VerifySMS API walkthrough for when you are ready to move off the compat layer.