Passer au contenu principal

Obtenir des Portefeuilles Clients

Vérifiez les soldes des portefeuilles clients dans différentes devises.

Créer une Entrée de Grand Livre

Ajoutez ou retirez des crédits des portefeuilles clients.

Lister les Entrées de Grand Livre

Consultez l’historique complet des transactions avec pagination.

​
Qu’est-ce que les Portefeuilles Clients ?

Considérez les portefeuilles clients comme des tirelires numériques pour vos utilisateurs. Chaque client en obtient un automatiquement lorsque vous créez son compte. Vous pouvez utiliser ces portefeuilles pour :
  • Suivre les soldes de crédit en USD et INR
  • Construire des systèmes de crédit API comme OpenAI ou Claude
  • Créer une facturation prépayée où les clients achètent des crédits à l’avance
  • Gérer les remboursements sous forme de crédits de portefeuille au lieu d’argent liquide
  • Gérer une facturation complexe avec un historique de transactions détaillé
Chaque client obtient automatiquement un portefeuille lorsque vous créez son compte. Les portefeuilles prennent en charge les devises USD et INR avec des soldes séparés pour chacune.
Portefeuilles Clients

​
Comment ça fonctionne

Les portefeuilles clients sont simples : ils contiennent de l’argent (crédits) que les clients peuvent dépenser pour vos services. Lorsqu’un client effectue un achat, le solde de son portefeuille est vérifié en premier, et tous les crédits disponibles sont utilisés avant de facturer son moyen de paiement.

​
Configuration Automatique

Lorsque vous créez un nouveau client, Dodo Payments crée automatiquement un portefeuille avec un solde de zéro. Il est prêt à être utilisé immédiatement via notre API.

​
Support Multi-Devises

Chaque portefeuille peut contenir des soldes dans différentes devises :
​
USD Balance
integer
Solde en Dollars Américains (stocké en cents)
​
INR Balance
integer
Solde en Roupies Indiennes (stocké en paise)
Actuellement, seuls les soldes en USD et INR sont disponibles. D’autres devises arriveront bientôt.

​
Travailler avec les Portefeuilles

​
Vérifier les Soldes Clients

Voyez combien de crédits un client a dans toutes les devises. Parfait pour vérifier s’il a suffisamment de fonds avant de traiter un achat.

Obtenir les Soldes des Portefeuilles Clients

Vérifiez les soldes de crédit du portefeuille d’un client dans toutes les devises prises en charge.

​
Ajouter ou Retirer des Crédits

Donnez des crédits aux clients (comme des bonus de bienvenue) ou déduisez des crédits (comme des frais d’utilisation). Vous pouvez ajouter des raisons pour chaque transaction afin de garder une trace de ce qui s’est passé.

Créer une Entrée de Grand Livre de Portefeuille Client

Ajoutez ou retirez des crédits du portefeuille d’un client.

​
Voir l’Historique des Transactions

Consultez chaque transaction de crédit et de débit pour un client. Idéal pour déboguer des problèmes de facturation ou montrer aux clients leur historique de dépenses.

Lister les Entrées de Grand Livre du Portefeuille Client

Consultez chaque transaction de crédit et de débit pour un client.

​
Exemples Concrets

​
Système de Crédit API (Comme OpenAI)

Construisez un système où les clients achètent des crédits et les dépensent sur des appels API : 
// Give new customers welcome credits
async function giveWelcomeCredits(customerId) {
  await client.customers.wallets.ledgerEntries.create(customerId, {
    amount: 10000, // $100 in cents
    currency: 'USD',
    entry_type: 'credit',
    reason: 'Welcome bonus - 100 API credits',
    idempotency_key: `welcome_${customerId}_${Date.now()}`
  });
}

// Charge customers for API usage
async function chargeForApiUsage(customerId, usageCost) {
  try {
    await client.customers.wallets.ledgerEntries.create(customerId, {
      amount: usageCost, // Cost in cents
      currency: 'USD',
      entry_type: 'debit',
      reason: `API usage - ${usageCost} credits consumed`,
      idempotency_key: `usage_${customerId}_${Date.now()}`
    });
  } catch (error) {
    if (error.status === 400) {
      console.log('Customer needs to buy more credits');
    }
  }
}

​
Système de Facturation Prépayée

Permettez aux clients d’acheter des crédits à l’avance et de les dépenser au fil du temps :
1

Accueillir les Nouveaux Clients

Donnez aux nouveaux clients des crédits gratuits pour commencer.
await client.customers.wallets.ledgerEntries.create(customerId, {
  amount: 5000, // $50 welcome bonus
  currency: 'USD',
  entry_type: 'credit',
  reason: 'Welcome bonus for new customer',
  idempotency_key: `welcome_${customerId}`
});
2

Gérer les Achats de Crédits

Lorsque les clients achètent des crédits, ajoutez-les à leur portefeuille.
await client.customers.wallets.ledgerEntries.create(customerId, {
  amount: purchaseAmount, // Amount paid in cents
  currency: 'USD',
  entry_type: 'credit',
  reason: `Credit purchase - ${purchaseAmount} credits`,
  idempotency_key: `purchase_${paymentId}`
});
3

Facturer pour l'Utilisation

Déduisez des crédits lorsque les clients utilisent votre service.
await client.customers.wallets.ledgerEntries.create(customerId, {
  amount: usageCost,
  currency: 'USD', 
  entry_type: 'debit',
  reason: `Service usage - ${usageCost} credits`,
  idempotency_key: `usage_${usageId}`
});
4

Surveiller les Soldes

Vérifiez si les clients sont à court de crédits.
const wallets = await client.customers.wallets.list(customerId);
const usdWallet = wallets.items.find(w => w.currency === 'USD');
const balance = usdWallet.balance;

if (balance < 1000) { // Less than $10
  // Send low balance notification
  await sendLowBalanceNotification(customerId, balance);
}

​
Support Multi-Devises

Gérez des clients dans différents pays :
Donnez des crédits en USD aux clients basés aux États-Unis.
await client.customers.wallets.ledgerEntries.create(customerId, {
  amount: 20000, // $200 in cents
  currency: 'USD',
  entry_type: 'credit',
  reason: 'USD credit purchase',
  idempotency_key: `usd_purchase_${paymentId}`
});
Donnez des crédits en INR aux clients indiens.
await client.customers.wallets.ledgerEntries.create(customerId, {
  amount: 1500000, // ₹15,000 in paise
  currency: 'INR',
  entry_type: 'credit',
  reason: 'INR credit purchase',
  idempotency_key: `inr_purchase_${paymentId}`
});

​
Meilleures Pratiques

​
Prévenir les Transactions Dupliquées

Utilisez des clés d’idempotence pour vous assurer de ne pas facturer accidentellement les clients deux fois pour la même chose : 
async function addCreditsSafely(customerId, amount, reason) {
  const idempotencyKey = `${reason}_${customerId}_${Date.now()}`;
  
  try {
    const result = await client.customers.wallets.ledgerEntries.create(customerId, {
      amount: amount,
      currency: 'USD',
      entry_type: 'credit',
      reason: reason,
      idempotency_key: idempotencyKey
    });
    
    return { success: true, wallet: result };
  } catch (error) {
    if (error.status === 400 && error.message.includes('Insufficient balance')) {
      return { success: false, error: 'INSUFFICIENT_BALANCE' };
    }
    
    if (error.status === 409) {
      // Transaction already processed
      return { success: true, wallet: null, duplicate: true };
    }
    
    throw error;
  }
}

​
Vérifier les Soldes Avant de Facturer

Vérifiez toujours que les clients ont suffisamment de crédits avant de traiter des opérations coûteuses : 
async function checkBalanceBeforeOperation(customerId, requiredAmount) {
  const wallets = await client.customers.wallets.list(customerId);
  const usdWallet = wallets.items.find(w => w.currency === 'USD');
  
  if (!usdWallet || usdWallet.balance < requiredAmount) {
    throw new Error('Not enough credits for this operation');
  }
  
  return usdWallet.balance;
}

​
Qu’est-ce qui arrive ensuite

Ces fonctionnalités sont prévues pour de futures versions :
  • Expiration des Crédits : Définissez une date d’expiration pour les crédits après un certain temps
  • Meilleures Analyses : Rapports de dépenses détaillés et insights d’utilisation
  • Plus de Webhooks : Notifications en temps réel pour les changements de solde et les crédits bas
Commencez simplement avec des opérations de crédit/débit de base, puis ajoutez des fonctionnalités plus complexes à mesure que votre entreprise se développe.