Comment Utiliser l'API Plaid (Guide Développeur 2026)

Les applications fintech ne partent quasiment jamais de zéro. Lorsque vous intégrez un compte bancaire à votre produit, Plaid est souvent l’intermédiaire qui convertit les identifiants bancaires de l’utilisateur en un JSON exploitable par votre backend. L’API Plaid gère la connexion de comptes, la vérification de solde, l’accès à l’historique des transactions et la vérification d’identité pour des milliers d’applications (Venmo, Robinhood, Chime, etc.).

Essayez Apidog dès aujourd'hui

Ce guide explique comment utiliser Plaid côté développeur : obtenir vos clés, comprendre le flux Link end-to-end, connaître les produits principaux, diagnostiquer les erreurs courantes, et tester chaque étape avec Apidog. Pour des détails exhaustifs, gardez la documentation officielle Plaid ouverte en parallèle. Si vous comparez les solutions open banking, notre comparatif des meilleures API open banking peut vous aider. Ici, on part du principe que vous avez choisi Plaid et que vous souhaitez passer à l’implémentation.

En bref

• Plaid connecte votre application à plus de 12 000 banques (US, CA, Europe).
• Trois environnements : sandbox (fictif, gratuit), développement (100 Items réels gratuits), production (facturation à l’usage).
• Flux de liaison en 4 étapes : créer un link_token (serveur), ouvrir Plaid Link (client), échanger le public_token contre un access_token (serveur), appeler les endpoints des produits.
• Produits principaux : Auth, Balance, Transactions, Identity, Investments, Liabilities, Income. Activation par Item.
• Erreurs fréquentes : ITEM_LOGIN_REQUIRED, INVALID_CREDENTIALS. Les webhooks vous alertent quand un Item nécessite une action.
• Les limites de débit sont par Item et par client. Groupez les lectures et écoutez les webhooks (évitez le polling).

Qu'est-ce que Plaid ?

Plaid est une couche d’infrastructure fintech qui s’intercale entre votre app et la banque de l’utilisateur. L’utilisateur renseigne ses identifiants dans Plaid Link ; Plaid s’occupe de la connexion (via API officielle ou scraping selon la banque), extrait les données, les normalise, et vous renvoie un JSON cohérent.

Vous ne manipulez jamais directement les identifiants bancaires de l’utilisateur. Plaid gère la « connexion » (un Item) et vous fournit un access_token pour interroger cet Item. Un Item = un jeu d’identifiants auprès d’une institution, potentiellement plusieurs comptes (courant, épargne, CB…).

Plaid couvre comptes courants/épargne, cartes de crédit, prêts, investissements, et données de paie. Il ne traite pas les paiements : pour l’ACH, combinez Plaid Auth à un PSP. Pour cela, lisez notre comparatif des meilleures API de paiement ACH.

Authentification et configuration

Étape 1 : Créer un compte développeur Plaid

Inscrivez-vous sur plaid.com puis validez votre email. Le dashboard Plaid donne accès à trois environnements :

• Sandbox : banques et utilisateurs fictifs, gratuit. Utilisez user_good / pass_good pour tester.
• Développement : vraies banques, limité à 100 Items actifs, gratuit.
• Production : connexions réelles, illimité, facturé à l’usage.

Étape 2 : Récupérer vos clés

Depuis le dashboard, ouvrez Paramètres d’équipe > Clés. Notez :

• client_id (commune à tous les environnements)
• secret (différent pour chaque environnement)

Stockez-les en variables d’environnement, jamais en clair dans le code.

Étape 3 : Installer le SDK

Installez le SDK Node.js officiel (github.com/plaid/plaid-node) :

npm install plaid

Étape 4 : Initialiser le client

import { Configuration, PlaidApi, PlaidEnvironments } from 'plaid';

const config = new Configuration({
  basePath: PlaidEnvironments.sandbox,
  baseOptions: {
    headers: {
      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
      'PLAID-SECRET': process.env.PLAID_SECRET,
    },
  },
});

const client = new PlaidApi(config);

Remplacez PlaidEnvironments.sandbox par .development ou .production selon l’environnement.

Points de terminaison principaux

Le flux de jetons Link (Link Token Flow)

Intégrez Plaid via ces 4 étapes :

1. Créer un link_token (serveur)

const response = await client.linkTokenCreate({
  user: { client_user_id: 'user_123' },
  client_name: 'Your App',
  products: ['auth', 'transactions'],
  country_codes: ['US'],
  language: 'en',
});

const linkToken = response.data.link_token;

En curl :

curl -X POST https://sandbox.plaid.com/link/token/create \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "YOUR_CLIENT_ID",
    "secret": "YOUR_SANDBOX_SECRET",
    "user": { "client_user_id": "user_123" },
    "client_name": "Your App",
    "products": ["auth", "transactions"],
    "country_codes": ["US"],
    "language": "en"
  }'

2. Ouvrir Plaid Link côté client

Envoyez le link_token au frontend, passez-le au SDK Plaid Link. L’utilisateur choisit sa banque, s’authentifie : Plaid retourne un public_token via le callback onSuccess du SDK.

3. Échanger le public_token (serveur)

const exchange = await client.itemPublicTokenExchange({
  public_token: publicToken,
});

const accessToken = exchange.data.access_token;
const itemId = exchange.data.item_id;

Stockez accessToken côté serveur, lié à l’utilisateur. Il sert pour tous les appels ultérieurs.

4. Appeler les endpoints des produits

const accounts = await client.accountsGet({ access_token: accessToken });
const balance = await client.accountsBalanceGet({ access_token: accessToken });

Points de terminaison produits à connaître

• Auth : Récupère les numéros de compte/routing pour ACH (/auth/get).
• Balance : Soldes instantanés, non mis en cache (/accounts/balance/get).
• Transactions : Jusqu’à 24 mois d’historique nettoyé (/transactions/sync).
• Identity : Titulaire, email, téléphone, adresse (/identity/get). Pour des besoins KYC purs, comparez avec des solutions dédiées dans notre guide KYC.
• Investments : Portefeuilles et transactions boursières (/investments/holdings/get).
• Liabilities : Prêts étudiants, cartes de crédit, hypothèques (/liabilities/get).
• Income : Données de paie (/credit/payroll_income/get).

Tester l’API Plaid avec Apidog

Tester Plaid bout en bout peut être complexe à cause du composant Link côté client. Pour automatiser et partager vos appels backend, Apidog est très efficace.

• Importez la spec OpenAPI Plaid dans Apidog : tous les endpoints sont préconfigurés, avec exemples et headers d’auth.
• Paramétrez vos variables d’environnement (client_id, secret, access_token), et basculez sandbox/production en un clic.
• Enchaînez les requêtes : linkTokenCreate → sandboxPublicTokenCreate → itemPublicTokenExchange → accountsGet dans un seul flow pour tester tout l’échange sans navigateur.
• Utilisez le mock server Apidog pour fournir des réponses /accounts/get factices au frontend pendant que l’intégration backend avance.
• Suivez notre guide sur le test d’API sans Postman en 2026 pour migrer rapidement.
• Téléchargez Apidog et pointez-le sur la spec Plaid pour démarrer.

Erreurs courantes et limites de débit

Les erreurs Plaid incluent toujours : error_type, error_code, error_message. Voici les plus critiques à gérer :

• INVALID_CREDENTIALS : Mauvais mot de passe bancaire. Demandez à l’utilisateur de ré-authentifier via Link en mode update.
• ITEM_LOGIN_REQUIRED : Session bancaire invalide (mot de passe changé, MFA). Relancez Link en mode update. Vous serez notifié via webhook.
• RATE_LIMIT_EXCEEDED : Limite atteinte (par Item ou endpoint). Rajoutez un backoff aléatoire avant retry.
• PRODUCT_NOT_READY : Les données (ex : transactions) ne sont pas encore dispos. Réessayez après le webhook INITIAL_UPDATE.

Webhooks

Spécifiez une URL webhook lors de la création du link_token. Plaid y enverra les notifications :

• SYNC_UPDATES_AVAILABLE : nouvelles transactions
• ITEM: LOGIN_REQUIRED : réauthentification nécessaire
• ITEM: ERROR : échec permanent

Vérifiez la signature JWT de chaque webhook.

Limites de débit

• Par Item et par endpoint. Par exemple, /accounts/balance/get : ~5 appels/minute/Item en prod.
• Des limites globales s’appliquent aussi.
• Bonnes pratiques : consommez les webhooks, mettez en cache les soldes quelques minutes, n’appelez jamais Plaid dans le flux direct utilisateur.

Tarification Plaid

• Sandbox : illimité, gratuit
• Développement : gratuit jusqu’à 100 Items
• Production :
  • Auth : ~1,50 $ / compte lié (une fois)
  • Balance : à l’appel
  • Transactions : mensuel / Item (~0,30 $)
  • Identity : à l’appel
  • Investments / Liabilities / Income : frais distincts par Item

Au-delà de certains volumes, tarif négocié. Consultez la page produits Plaid pour les tarifs à jour.

FAQ

Combien de temps dure un access_token ?

Indéfiniment, sauf révocation par l’utilisateur ou la banque. Stockez-le chiffré, ne forcez pas d’expiration côté serveur.

Puis-je utiliser Plaid seulement pour la vérification d’identité ?

Oui : utilisez Plaid Identity. Mais pour du KYC pur, comparez avec des solutions spécialisées (exemple Stripe Identity).

Plaid fonctionne-t-il hors US ?

Oui, Plaid couvre US, Canada, UK, UE (support variable selon le produit). Indiquez les codes pays dans /link/token/create.

Que faire si l’utilisateur change son mot de passe bancaire ?

L’Item passe en ITEM_LOGIN_REQUIRED ; vous recevez un webhook. Relancez Link en mode mise à jour, l’utilisateur se réauthentifie et l’access_token reste valide.

Peut-on tester le flux Link sans navigateur ?

Oui, le endpoint /sandbox/public_token/create génère un public_token sans Link : parfait pour les tests d’intégration.

Comment gérer Plaid en local ?

Stockez le secret sandbox dans .env, ciblez PlaidEnvironments.sandbox. Utilisez un tunnel (ngrok, Cloudflare Tunnel) pour recevoir les webhooks en local.