# Intégration avec l'IA

> Intégrez 2328.io dans votre application en quelques minutes en utilisant des assistants IA tels que Claude, ChatGPT, Cursor et GitHub Copilot.

La documentation de 2328.io est conçue pour être **adaptée aux LLM**. Vous pouvez transmettre l'intégralité de la référence API à n'importe quel assistant IA moderne et obtenir une intégration fonctionnelle dans le langage de votre choix — PHP, Node.js, Python, Go, Rust — en quelques minutes au lieu de quelques heures.

Cette page explique comment le faire efficacement.

## Pourquoi utiliser l'IA pour intégrer

- **Démarrage plus rapide** — sautez le code répétitif, allez directement à la logique métier
- **Signature correcte** — l'IA reproduit fidèlement la signature HMAC-SHA256 dans tous les langages
- **Gestionnaires de webhook** — générez la vérification de signature et des gestionnaires idempotents prêts à l'emploi
- **À jour** — notre `llms-full.txt` est régénéré à chaque mise à jour de la documentation, vous obtenez toujours les schémas actuels

## Documentation lisible par machine

Nous publions trois endpoints suivant le standard [llmstxt.org](https://llmstxt.org) :

| Endpoint | Objectif |
|----------|----------|
| [`/llms.txt`](https://doc.2328.io/llms.txt) | Index court de toute la documentation avec des liens |
| [`/llms-full.txt`](https://doc.2328.io/llms-full.txt) | Documentation complète sous forme de fichier unique — collez-la dans votre conversation IA |
| [`/md/{locale}/{slug}`](https://doc.2328.io/md/en/payments) | N'importe quelle page au format Markdown brut |

Chaque page HTML expose également `<link rel="alternate" type="text/markdown">` pointant vers sa version Markdown, afin que les crawlers IA la découvrent automatiquement.

## Démarrage rapide avec Claude ou ChatGPT

### Étape 1 — Fournir la documentation

Ouvrez une nouvelle conversation et collez le contenu de [`llms-full.txt`](https://doc.2328.io/llms-full.txt) comme premier message, ou partagez simplement le lien si le modèle peut le récupérer.

### Étape 2 — Décrire votre stack

Indiquez à l'assistant ce que vous construisez :

```
I'm building a Laravel 11 application. I need to:
1. Create a payment for an order (amount in USD, user pays in USDT TRC20)
2. Handle the webhook and credit the user's balance
3. Store payment records in a `payments` table

Use the 2328.io API above. Include HMAC signing, webhook signature
verification, and idempotency.
```

### Étape 3 — Vérifier et tester

L'assistant produira un contrôleur, une classe de service et un gestionnaire de webhook. Avant de déployer :

- Vérifiez que `apiSign()` encode le corps en Base64 **avant** HMAC-SHA256
- Vérifiez que les gestionnaires de webhook utilisent `hash_equals()` (et non `===`) pour comparer les signatures
- Assurez-vous que le gestionnaire est idempotent — vérifiez `order_id` / `txid` avant de créditer
- Testez d'abord avec un petit paiement réel sur un environnement de développement

> **WARNING:** Ne déployez jamais du code de paiement généré par l'IA sans réviser la logique de signature et de vérification des webhooks. Ce sont les frontières de sécurité critiques.

## Intégrations IDE

### Cursor

Ajoutez la documentation comme source personnalisée dans les paramètres Cursor :

```
Settings → Features → Docs → Add new doc
URL: https://doc.2328.io
```

Puis dans la conversation, préfixez votre question avec `@2328.io` :

```
@2328.io generate a webhook handler in Next.js App Router
with signature verification and idempotent credit logic
```

### GitHub Copilot

Copilot Chat peut lire `llms-full.txt` directement :

```
#fetch https://doc.2328.io/llms-full.txt

Using the 2328.io API docs above, implement a payout endpoint
in Express that withdraws USDT BEP20 to a user-supplied address.
```

### Windsurf / Continue / autres assistants

Tout assistant prenant en charge un contexte URL ou une pièce jointe fonctionne de la même manière — joignez `llms-full.txt` et décrivez votre objectif.

## API Claude (Agent SDK)

Si vous construisez votre propre agent ou chatbot devant interagir avec 2328.io, injectez la documentation une seule fois dans le prompt système :

```python
from anthropic import Anthropic
import urllib.request

docs = urllib.request.urlopen(
    "https://doc.2328.io/llms-full.txt"
).read().decode()

client = Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    system=f"""You are an integration assistant for 2328.io.
Use the API reference below to answer questions and generate code.

<docs>
{docs}
</docs>""",
    messages=[
        {"role": "user", "content": "Write a Python function that creates a USDT payment"}
    ],
)

print(response.content[0].text)
```

> **INFO:** Le fichier de documentation complet fait environ 15 Ko — bien en dessous de la limite de contexte de tout modèle moderne. Vous pouvez le mettre en cache de votre côté et le rafraîchir une fois par jour.

## Exemples de prompts qui fonctionnent bien

Copiez ceux-ci dans Claude, ChatGPT ou votre IDE IA après avoir partagé `llms-full.txt` :

**Intégration backend complète :**
```
Build a Node.js + Express service that exposes two routes:
- POST /checkout → creates a 2328.io payment and returns the payment URL
- POST /webhook/2328 → verifies the signature and marks the order as paid
Use TypeScript, Zod for validation, and a simple in-memory store.
```

**Outil de retrait :**
```
Write a CLI in Go that takes a currency, network, amount, and address
and creates a payout via the 2328.io Payout API. Use a separate payout
API key from env. Poll the status endpoint until the payout is completed.
```

**Portefeuille statique pour les dépôts utilisateur :**
```
I have a Django app where users deposit USDT TRC20 to top up their balance.
Each user should have a permanent deposit address. Implement this using
2328.io static wallets, including the webhook handler that credits their
balance when a deposit arrives.
```

## Bonnes pratiques pour l'intégration assistée par IA

- **Partez de `llms-full.txt`** — il est conçu pour le contexte LLM, sans code répétitif
- **Soyez précis sur votre stack** — framework, version du langage, ORM
- **Demandez des tests** — l'IA est efficace pour générer des tests unitaires de la logique de signature
- **Vérifiez la gestion des erreurs** — l'IA omet parfois les chemins d'échec
- **Révisez manuellement le code de signature** — c'est la seule partie qui *doit* être absolument exacte
- **Rafraîchissez périodiquement** — si notre API change, récupérez à nouveau `llms-full.txt` et reformulez votre prompt