API Reference
Documentation complète de l'API REST YaniPay. Intégrez les fonctionnalités DeFi, wallet et paiements dans vos applications.
Overview
L'API YaniPay fournit un accès programmatique à toutes les fonctionnalités de la plateforme : gestion de wallets multi-chain, trading DeFi, staking, yield farming, et gouvernance DAO.
Performante
Latence moyenne <50ms, 99.9% uptime SLA
Sécurisée
TLS 1.3, authentification API Key + HMAC
Temps réel
WebSocket pour les prix et événements
Technologies YaniPay
L'API YaniPay s'appuie sur deux technologies propriétaires qui alimentent toutes les fonctionnalités de la plateforme.
YaniChain Blockchain
Infrastructure DeFi sous-jacente : 50K+ TPS, finalité 6s, gas $0.001. Toutes les APIs transactionnelles utilisent YaniChain.
Y.A.N.I. Intelligence
IA conversationnelle intégrée : analyse de portefeuille, détection de fraude temps réel, recommandations personnalisées.
API optimisée par Y.A.N.I.
Authentication
Toutes les requêtes API doivent inclure une clé API dans le headerAuthorization. Vous pouvez obtenir votre clé API depuis le dashboard développeur.
curl -X GET "https://api.yanipay.com/v1/wallets" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"API Key Security
Ne partagez jamais votre API key. Utilisez des variables d'environnement et rotez vos clés régulièrement. Les clés compromises doivent être révoquées immédiatement.
Types d'authentification
- API Key : Pour les requêtes serveur-to-serveur
- JWT Token : Pour les applications client (obtenu via OAuth2 ou authentification directe)
- HMAC Signature : Pour les opérations sensibles (retraits, transferts)
Architecture d'authentification interne
YaniPay utilise une architecture d'authentification unifiée basée sur JWT custom pour toutes les routes API protégées :
import { getCurrentUser } from '@/lib/auth';
export async function GET() {
// Unified JWT authentication
const authResult = await getCurrentUser();
if (!authResult.success || !authResult.user) {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
const { userId, email } = authResult.user;
// Continue with authenticated operations...
}Dual Authentication System
NextAuth.js v5 gère OAuth et les layouts protégés, tandis quegetCurrentUser()est utilisé pour toutes les routes API. Cette architecture garantit cohérence et sécurité à travers l'application.
API Endpoints
L'API YaniPay est organisée en 6 domaines fonctionnels :
Wallets API
Multi-chain wallet management, balances, and transactions
Staking API
Stake tokens, manage validators, and claim rewards
DEX API
Decentralized exchange, liquidity pools, and swaps
Farming API
Yield farming pools, deposits, and harvesting
Governance API
DAO proposals, voting, and delegation
Prices API
Real-time asset prices and oracle feeds
Quick Start Example
Voici un exemple complet pour récupérer le solde d'un wallet :
// Server Component — no 'use client' needed
import { getCurrentUser } from '@/lib/auth';
import { apiGet } from '@/lib/api/client';
interface WalletBalance {
id: string;
balance: number; // in cents
currency: string;
}
export default async function WalletPage() {
const auth = await getCurrentUser();
if (!auth.success || !auth.user) {
redirect('/auth/signin');
}
// Typed API call — handles 401 redirect and errors automatically
const wallet = await apiGet<WalletBalance>('/api/wallets/balance');
const formattedBalance = (wallet.balance / 100).toFixed(2);
return (
<div>
<h1>Balance : {formattedBalance} {wallet.currency}</h1>
</div>
);
}Rate Limits
Pour assurer la stabilité du service, l'API applique des limites de requêtes par fenêtre de temps.
| Plan | Requests/min | Requests/day | Burst |
|---|---|---|---|
| Free | 60 | 1,000 | 10 |
| Pro | 600 | 100,000 | 100 |
| Enterprise | 6,000 | Unlimited | 1,000 |
Les headers de réponse incluent les informations de rate limiting :
X-RateLimit-Limit: 600
X-RateLimit-Remaining: 598
X-RateLimit-Reset: 1706896800
Retry-After: 60 (only when rate limited)Error Handling
L'API utilise des codes HTTP standard. Toutes les erreurs retournent un objet JSON avec des détails.
{
"error": {
"code": "INSUFFICIENT_BALANCE",
"message": "Wallet balance is insufficient for this transaction",
"details": {
"required": "100.00",
"available": "50.00",
"currency": "YANI"
},
"request_id": "req_abc123xyz"
}
}HTTP Status Codes
Bad Request
Invalid request parameters or body
Unauthorized
Missing or invalid API key
Forbidden
Insufficient permissions for this resource
Not Found
Resource does not exist
Too Many Requests
Rate limit exceeded
Internal Server Error
Unexpected server error
Versioning
L'API utilise un versioning par URL. La version actuelle est v1. Les changements breaking sont introduits dans de nouvelles versions majeures.
/v1/*- Version stable actuelle (recommandée)/v2/*- Version beta (preview des nouvelles fonctionnalités)
Backward Compatibility
Les versions majeures sont supportées pendant minimum 12 mois après la sortie de la version suivante. Les deprecations sont annoncées 6 mois à l'avance.
Yani-Lab Orchestrator API
L'orchestrateur yani-lab expose une API REST dédiée à la gestion de jobs IA, runners, webhooks et templates. Sprint S6.26 (mai 2026) ajoute trois primitives clés : webhooks utilisateurs signés HMAC, job templates réutilisables et stream SSE de notifications.
C'est aussi le socle des transactions agent-to-agent (A2A) : un agent peut créer un job, déclencher un paiement, signer un escrow et notifier un autre agent via webhook — règlement on-chain en YANICoin, devise native de l'économie agentique YaniPay.
Webhooks signés
5 endpoints CRUD. Signature HMAC-SHA256 dans header X-Yani-Signature. Événements : job-done, job-failed, share-received.
Job templates
Préréglages réutilisables pour POST /api/jobs. Type, payload JSON, priorité 0-3, capability optionnelle.
Notifications SSE
GET /api/notifications/stream — Server-Sent Events. Évents snapshot, new, done. Polling 10 s, auto-close 5 min.
Webhooks — endpoints
| Méthode | Path | Description |
|---|---|---|
| POST | /api/webhooks | Crée un webhook. Body : { name, url, events?: string[] }. Retourne le secret HMAC en clair une seule fois. |
| GET | /api/webhooks | Liste les webhooks de l'utilisateur (sans secret). |
| PATCH | /api/webhooks/[id] | Active/désactive ou met à jour URL/events. Ownership requis. |
| DELETE | /api/webhooks/[id] | Supprime le webhook (cascade sur les WebhookDelivery pendantes). |
Vérifier la signature côté receveur
import { createHmac, timingSafeEqual } from 'crypto';
export function verifyYaniWebhook(
rawBody: string,
signature: string,
secret: string,
): boolean {
const expected = createHmac('sha256', secret)
.update(rawBody, 'utf8')
.digest('hex');
const a = Buffer.from(expected, 'hex');
const b = Buffer.from(signature, 'hex');
return a.length === b.length && timingSafeEqual(a, b);
}
// Express handler
app.post('/yanipay-webhook', (req, res) => {
const sig = req.header('X-Yani-Signature');
const event = req.header('X-Yani-Event');
if (!sig || !verifyYaniWebhook(req.rawBody, sig, process.env.YP_WH_SECRET!)) {
return res.status(401).end();
}
// event ∈ { 'job-done', 'job-failed', 'share-received' }
console.log(event, req.body);
res.status(204).end();
});Best-effort delivery
WebhookDelivery pour la retry exponentielle et la dead letter queue.Spécification OpenAPI
Le fichier docs/api/openapi-v1.yamlfournit la spécification complète de l'API au format OpenAPI 3.0.3. Il couvre 38 paths et 43 opérations documentées.
openapi-v1.yaml
NEWPaths
38
Opérations
43
Version
3.0.3
X-API-Key: yp_live_* ou yp_test_*POST /api/v1/mobile/auth/loginVisualiser avec Swagger UI
Lancez une instance Swagger UI locale pour explorer et tester l'API de manière interactive :
# Servir le fichier OpenAPI et lancer Swagger UI
docker run -p 8080:8080 \
-e SWAGGER_JSON_URL=/api/openapi-v1.yaml \
swaggerapi/swagger-ui
# Accéder à l'interface
open http://localhost:8080# Valider la spec avec Spectral (recommandé)
npx @stoplight/spectral-cli lint docs/api/openapi-v1.yaml
# Ou avec swagger-cli
npx @apidevtools/swagger-cli validate docs/api/openapi-v1.yamlNext Steps
Technologies YaniPay
Last updated: 2026-05-07