API temps réel B2B · WebSocket + REST

API Twitter (X) temps réel
WebSocket et REST pour bots de trading, terminaux et agents, sans scraper à maintenir

Xanguard B2B est l'API de données Twitter (X) en temps réel pour développeurs. Une seule connexion WebSocket t'envoie en JSON les nouveaux tweets, suppressions, changements de profil, nouveaux abonnés et follows/unfollows des comptes que tu surveilles ; une API REST gère ta liste. Détection médiane d'environ 200 ms avec les offres payantes (mesures publiques). Dès 49 $ par mois pour 50 comptes, jusqu'à 1 000 comptes, paiement en SOL, activation automatique.

Prix vérifiés le 5 octobre 2026

Salut mon frère, tu construis un bot de trading ou un terminal ? Bienvenue chez Xanguard, toi et ton Agent. Intégration, devis, mapping de champs : écris-moi directement sur Telegram : @notAdegen

t.me/notAdegen Ouvrir dans l'app

Le développeur de Xanguard · je réponds moi-même à tes DM

Le lien ne s'ouvre pas ? Ouvre Telegram et cherche @B2B_Xanguard_bot

~200ms
Détection médiane
5 types
d'événements temps réel
1 000
Comptes max. (plus sur devis)
dès $49
par mois pour 50 comptes

Cinq types d'événements temps réel, un seul WebSocket

Tout ce dont un bot de trading ou un terminal a besoin côté Twitter : tweets, suppressions, changements de profil, nouveaux abonnés, follows/unfollows. En JSON, prêt à l'emploi.

Tweets twitter.post.new

Tweets, réponses, citations, retweets, détection médiane d'environ 200 ms. Texte complet, liens des médias, tweets cités et tweets auxquels on répond, profil de l'auteur, extraction automatique des adresses de contrat. Toutes les offres.

Suppressions twitter.tweet.deleted

Envoyé quand un compte surveillé supprime un tweet, avec l'ID et le texte du tweet supprimé ; si l'on sait qu'une suppression a eu lieu sans pouvoir dire laquelle, ces deux champs valent null. Toutes les offres.

Changements de profil twitter.profile.update

Changement de nom, de bio, d'avatar, de tweet épinglé, avec la valeur avant et après. Quand un projet change de récit ou de look, ça commence souvent par le profil. Pro et plus.

Nouveaux abonnés twitter.follower.new

Envoyé quand un compte surveillé gagne un abonné, avec l'identité de la personne. Utile pour voir qui se met discrètement à suivre les devs de premier plan. Pro et plus.

API REST

Avec une clé dt_, ajoute ou retire des comptes surveillés (POST /v1/dt/targets), consulte les profils et l'historique des changements. L'OCR des adresses de contrat dans les images est inclus avec Enterprise.

Branché en 5 minutes, les événements arrivent

Pas de réunion, pas de commercial. Tu commandes dans le bot, tu reçois ta clé, tu te connectes.

1

Abonne-toi

Ouvre @B2B_Xanguard_bot sur Telegram, choisis une offre et paie en SOL.

2

Récupère ta clé

Après confirmation on-chain, l'activation est automatique et le bot t'envoie ta clé d'API, qui commence par dt_.

3

Ajoute des comptes

Dans le bot avec /add et un pseudo, ou via POST /v1/dt/targets.

4

Connecte le WebSocket

Après la connexion tu reçois HELLO ; envoie LOGIN (op 2 + clé), puis les EVENT arrivent en continu.

Protocole d'opcodes, exemples Python / Node prêts à lancer

Adresse : wss://api.xanguard.tech/v1/dt/realtime/ws. Déroulé d'opcodes compatible avec TweetCatcher ; 5 connexions simultanées maximum par clé, déconnexion si aucun heartbeat pendant 90 secondes.

opNomSensDescription
10HELLOserveur → clientEnvoyé dès la connexion, avec heartbeat_interval (en ms)
2LOGINclient → serveurEnvoie la clé d'API dans les 15 secondes : {"op": 2, "d": "dt_..."}
4READYserveur → clientAuthentification réussie, avec les modules activés et le nombre de comptes
0EVENTserveur → clientÉvénement temps réel, d.event donne le type
1HEARTBEATclient → serveurÀ envoyer selon heartbeat_interval
11HEARTBEAT_ACKserveur → clientRéponse au heartbeat
3DISCONNECTserveur → clientDéconnexion, d.reason donne la raison (clé invalide ou expirée, par exemple)
Python (pip install websockets)
import asyncio, json
import websockets

URL = "wss://api.xanguard.tech/v1/dt/realtime/ws"
API_KEY = "dt_ta_cle"

async def main():
    async with websockets.connect(URL) as ws:
        # op 10 HELLO : donne l'intervalle de heartbeat (en ms)
        hello = json.loads(await ws.recv())
        interval = hello["d"]["heartbeat_interval"] / 1000

        # op 2 LOGIN : envoie la clé dans les 15 secondes
        await ws.send(json.dumps({"op": 2, "d": API_KEY}))
        ready = json.loads(await ws.recv())
        if ready["op"] != 4:  # en cas d'échec : op 3 DISCONNECT
            raise SystemExit(ready["d"].get("reason"))
        print("connecté :", ready["d"]["modules"])

        # heartbeat selon l'intervalle ; sans heartbeat pendant 90 s, déconnexion
        async def heartbeat():
            while True:
                await asyncio.sleep(interval)
                await ws.send(json.dumps({"op": 1}))
        hb = asyncio.create_task(heartbeat())

        async for raw in ws:
            msg = json.loads(raw)
            if msg["op"] != 0:  # on ne traite que op 0 EVENT
                continue
            ev, d = msg["d"]["event"], msg["d"]["data"]
            if ev == "twitter.post.new":
                print(d["author"]["handle"], d["text"])
            elif ev == "twitter.tweet.deleted":
                print("tweet supprimé :", d["tweet_id"])
            elif ev == "twitter.profile.update":
                print("changement de profil :", d["field"], d["updated"])

asyncio.run(main())
Node.js (npm i ws)
const WebSocket = require('ws');
const URL = 'wss://api.xanguard.tech/v1/dt/realtime/ws';
const ws = new WebSocket(URL);
let hb;

ws.on('message', (raw) => {
  const msg = JSON.parse(raw.toString());
  switch (msg.op) {
    case 10: // HELLO : envoie LOGIN et lance le heartbeat
      ws.send(JSON.stringify({ op: 2, d: 'dt_ta_cle' }));
      hb = setInterval(
        () => ws.send(JSON.stringify({ op: 1 })),
        msg.d.heartbeat_interval
      );
      break;
    case 4: // READY : authentification réussie
      console.log('connecté', msg.d.modules);
      break;
    case 3: // DISCONNECT : clé invalide ou expirée, etc.
      console.error('déconnecté :', msg.d.reason);
      break;
    case 0: { // EVENT : événement temps réel
      const { event, data } = msg.d;
      if (event === 'twitter.post.new') {
        console.log(data.author.handle, data.text);
      } else if (event === 'twitter.following.new') {
        console.log('nouveau follow :', data.handle);
      }
      break;
    }
  }
});

ws.on('close', () => clearInterval(hb));

À quoi ressemble le JSON

Données d'exemple ; les champs de référence sont ceux de la documentation de l'API (en anglais). Un événement de tweet peut d'abord arriver en twitter.post.new, puis être complété par un twitter.post.update avec le même data.id.

twitter.post.new
{
  "op": 0,
  "d": {
    "event": "twitter.post.new",
    "event_id": "evt_1234567890123456789",
    "task_info": {"handle": "example_dev"},
    "data": {
      "id": "1234567890123456789",
      "created_at": 1712000000000,
      "type": "post",
      "text": "gm, nouvelle version ce soir",
      "media": [],
      "author": {
        "id": "1234567890",
        "handle": "example_dev",
        "name": "Example Dev",
        "stats": {"followers": 12000, "following": 800}
      },
      "in_reply_to": null,
      "quoted_tweet": null
    }
  }
}
twitter.following.new (Enterprise)
{
  "op": 0,
  "d": {
    "event": "twitter.following.new",
    "event_id": "evt_f_example_dev_1712000000000",
    "event_time": 1712000000000,
    "task_info": {"handle": "example_dev", "id": "1234567890"},
    "data": {
      "id": "2233445566",
      "handle": "example_founder",
      "name": "Example Founder",
      "bio": "building on Solana",
      "followers": 5400,
      "following": 310
    }
  }
}
twitter.profile.update (Pro et plus)
{
  "op": 0,
  "d": {
    "event": "twitter.profile.update",
    "event_id": "evt_p_example_dev_1712000000000",
    "task_info": {"handle": "example_dev"},
    "data": {
      "field": "bio",
      "prev": "Old bio text",
      "updated": "New bio text"
    }
  }
}
twitter.follower.new / twitter.tweet.deleted
{
  "op": 0,
  "d": {
    "event": "twitter.follower.new",
    "task_info": {"handle": "example_dev"},
    "data": {
      "id": "12345678",
      "handle": "newfollower",
      "name": "New Follower"
    }
  }
}

{
  "op": 0,
  "d": {
    "event": "twitter.tweet.deleted",
    "task_info": {"handle": "example_dev"},
    "data": {
      "tweet_id": "1234567890123456789",
      "text": "texte du tweet supprimé"
    }
  }
}

Valeurs de data.type : post, reply, quote, repost. Valeurs de field pour un changement de profil : bio, name, avatar, pinned_tweet.

Des paliers selon les modules, un prix selon le nombre de comptes

Choisis d'abord le palier de modules, puis le nombre de comptes surveillés. Prix par mois, en dollars, payés en SOL, vérifiés le 5 octobre 2026.

Starter
dès $49/mois
  • Événements de tweets
  • Événements de suppression
  • WebSocket + REST
Enterprise
dès $249/mois
  • Tout Pro
  • Événements follow/unfollow
  • OCR des adresses de contrat dans les images
Comptes surveillésStarter
tweets + suppressions
Pro
+ profil + nouveaux abonnés
Enterprise
+ follows/unfollows
Starter par compte
50 $49 $99 $249 $0.98
250 $229 $429 $979 $0.92
500 $449 $749 $1 649 $0.90
1 000 $849 $1 349 $2 849 $0.85

Au-delà de 1 000 comptes, on en discute. Option CA Search (recherche par adresse de contrat, nom de token ou mot-clé dans les tweets des dernières 24 h, 200 résultats maximum par requête) : 1 000 requêtes par jour $100 par mois, 2 000 requêtes $180, 5 000 requêtes $250. Grille complète en anglais : B2B API pricing.

Combien coûte la surveillance temps réel de 200 comptes par mois

Les prix des tiers viennent de leurs sites officiels, vérifiés le 20 septembre 2026 ; le prix de l'API officielle X a été vérifié le 5 octobre 2026 (docs.x.com). Référence-toi toujours aux prix actuels de chaque site.

Solution200 comptes par moisRemarques
Xanguard B2B Starter 250$229WebSocket + REST, suppressions incluses, jusqu'à 250 comptes
TweetStream (offre Pro à 250 comptes)$499Prix affiché sur leur site
twitterapi.io (offre 150 comptes + 50 en supplément)environ $399Comptes supplémentaires à $2 pièce
API officielle X (paiement à l'usage)environ $210Lecture des tweets seulement : $0,005 par tweet, à 7 tweets par jour et par compte ; follows et changements de profil facturés en plus, avec limites de débit

Migrer depuis un autre service

  • TweetCatcher : le WebSocket suit un déroulé d'opcodes compatible (HELLO → LOGIN → EVENT + heartbeat). Change l'adresse et la clé, ajuste quelques champs différents, en général en moins d'une heure. Guide de migration (en anglais)
  • twitterapi.io : remplace l'URL des requêtes par api.xanguard.tech en gardant l'en-tête X-API-Key et la structure de données. Guide de migration (en anglais)
  • Autres fournisseurs : envoie-nous la documentation de l'API que tu utilises ou un exemple de données ; le mapping des champs est en général prêt en quelques heures, et on branche tout ensemble dans le même chat avec le développeur.

Ce qu'on ne propose pas pour l'instant

  • Le renvoi des tweets manqués pendant une coupure, quand le WebSocket se reconnecte.
  • Un SLA de disponibilité écrit.
  • Les alertes Discord natives ; le paiement se fait uniquement en SOL, pas par carte bancaire.
Pour qui : terminaux de trading, bots de trading Telegram, outils de copy-trading et de signaux, dashboards de données, et agents IA qui ont besoin de Twitter en temps réel. Tu veux juste recevoir les tweets sur Telegram ? @Xanguard_bot suffit, 1 compte gratuit.

Questions fréquentes

Oui. Xanguard B2B pousse par un seul WebSocket les tweets, suppressions, changements de profil, nouveaux abonnés et follows/unfollows des comptes que tu surveilles, avec une API REST en plus. Les prix dépendent du nombre de comptes et des modules : pour le palier Starter, 49 $ par mois pour 50 comptes, 229 $ pour 250, 449 $ pour 500, 849 $ pour 1 000. Paiement en SOL, activation automatique.
D'après la documentation développeur de X (docs.x.com, vérifiée le 5 octobre 2026), l'API officielle est désormais uniquement facturée à l'usage, sans les anciens forfaits mensuels Basic et Pro : 0,005 $ par tweet lu, 0,010 $ par utilisateur lu, avec un plafond de 3 millions de tweets lus par mois, au-delà duquel il faut négocier Enterprise avec X. Pour 50 comptes à 7 tweets par jour chacun, la seule lecture des tweets coûte environ 53 $ par mois ; les follows et changements de profil se paient en plus à la lecture, avec des limites de débit. Si tu veux seulement suivre en direct un ensemble de comptes précis, un service au forfait par compte est en général plus simple.
Avec les offres payantes, la détection médiane est d'environ 200 ms, avec p95 et p99 mis à jour chaque heure sur xanguard.tech/speed/. Chaque événement de tweet contient la date de publication du tweet lui-même, created_at (timestamp en millisecondes) : compare-la à ton heure de réception pour vérifier le délai toi-même.
La différence, ce sont les modules. Starter : tweets + suppressions ; Pro : en plus, changements de profil et nouveaux abonnés ; Enterprise : en plus, événements follow/unfollow. Les trois incluent WebSocket et REST, avec 50, 250, 500 ou 1 000 comptes au choix. L'extraction des adresses de contrat est dans toutes les offres ; la reconnaissance des adresses dans les images (OCR) n'existe qu'avec Enterprise.
Oui. Le WebSocket suit le même déroulé d'opcodes que TweetCatcher (HELLO, LOGIN, READY, EVENT, HEARTBEAT) : change l'adresse et la clé, ajuste quelques champs, et ça tourne, en général en moins d'une heure. Pour twitterapi.io, remplace l'URL des requêtes par api.xanguard.tech en gardant l'en-tête X-API-Key et la structure de données. Pour les autres fournisseurs, envoie-nous la documentation : le mapping des champs est en général prêt en quelques heures.
Ouvre @B2B_Xanguard_bot sur Telegram, choisis une offre et paie en SOL. L'offre s'active automatiquement après confirmation on-chain, et le bot t'envoie directement ta clé d'API : pas de réunion, pas d'attente d'un commercial. Pas de paiement par carte.
Un scraper, tu l'écris, tu le fais tourner et tu le répares quand il casse. Avec l'API de Xanguard, tu te connectes à un WebSocket, tu envoies ta clé et tu reçois des événements JSON ; pas de compte développeur X, pas de gestion de limites de débit. Tu paies au nombre de comptes surveillés, pas à la lecture. Limite honnête : tu ne surveilles que les comptes que tu ajoutes (jusqu'à 1 000 par offre), pas tout Twitter.
Il faut un flux qui envoie plus que des tweets, avec une latence publiée et un prix au nombre de comptes. L'API B2B de Xanguard envoie sur un WebSocket les tweets, suppressions, changements de profil, nouveaux abonnés et follows/unfollows, avec une détection médiane d'environ 200 ms (xanguard.tech/speed/) et created_at sur chaque tweet pour vérifier le délai toi-même. Filtres à la connexion : onlyCA (adresse de contrat) et onlyTicker ($cashtag). Dès 49 $ par mois pour 50 comptes.
Oui, l'événement twitter.tweet.deleted est inclus dans toutes les offres, avec l'ID du tweet et son texte quand Xanguard avait vu le tweet. Si une suppression est confirmée sans qu'on puisse identifier le tweet, les deux champs valent null. Détails : xanguard.tech/fr/deleted-tweets/.
Oui : ajoute elonmusk à tes comptes surveillés (POST /v1/dt/targets, ou /add dans le bot) et ses posts arrivent sur ton WebSocket. Sur les 30 jours jusqu'au 5 octobre 2026, la détection médiane sur @elonmusk était de 193 ms. Pour juste les recevoir sur Telegram : xanguard.tech/fr/elon-musk-tweet-alerts/.

Un seul WebSocket, du JSON prêt à l'emploi

Dès 49 $ par mois pour 50 comptes, paiement en SOL, clé envoyée automatiquement après confirmation on-chain.

Le lien ne s'ouvre pas ? Ouvre Telegram et cherche @B2B_Xanguard_bot