WalletDinfrastructure de portefeuille

Comment ça marche

De la clé d'API à des livres réconciliés en cinq étapes.

WalletD est une API REST devant un registre de référence. Voici le chemin que suit un paiement unique, de l'intégration d'un utilisateur à un mouvement que vos auditeurs peuvent recalculer.

Ouvrir la documentationRéserver une démo

Comment ça marche

La forme d'une intégration

  1. 1. Reflétez votre utilisateur

    Créez un utilisateur de portefeuille avec votre propre id externe. WalletD ouvre des comptes par finalité (espèces, points) la première fois que chacun est utilisé, il n'y a donc rien à provisionner au préalable.

  2. 2. Alimentez le portefeuille

    Démarrez un rechargement via Stripe. Le solde n'est crédité que lorsque la passerelle confirme par un webhook signé ou une requête de réconciliation, jamais sur un rappel client.

  3. 3. Déplacez l'argent

    Envoyez en pair-à-pair, prenez un paiement avec un blocage, ou répartissez une vente sur la marketplace. Chaque appel porte une clé d'idempotence et inscrit des lignes équilibrées dans le registre en une seule transaction.

  4. 4. Récompenses et règlement suivent

    Le cashback et les points sont octroyés au moment de la capture ; les frais et la commission sont répartis ; les versements produisent un relevé de règlement. Tout cela est inscrit dans les mêmes livres.

  5. 5. Lisez et vérifiez

    Lisez les soldes et l'historique via l'API, recevez des webhooks signés pour chaque événement, et laissez le vérificateur intégré recontrôler les invariants du registre selon un calendrier.

Alimentez un portefeuille, puis envoyez de l'argent

Alimentez un portefeuille, puis envoyez de l'argent

La même requête dans six langages. Les montants sont des unités mineures entières ; le registre s'occupe du reste.

# Fund a wallet, then send money. Balances only move on the ledger.
curl -sS -X POST "$WALLETD_API/v1/users" \
  -H "Authorization: Bearer $WALLETD_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: usr-42-create" \
  -d '{"external_id":"user-42","kind":"consumer","display_name":"Ada Lovelace","handle":"ada"}'

curl -sS -X POST "$WALLETD_API/v1/transfers" \
  -H "Authorization: Bearer $WALLETD_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: xfer-ada-grace-001" \
  -d '{"from":"user-42","to":"@grace","amount":2500,"currency":"USD"}'
client := walletd.New(os.Getenv("WALLETD_API"), os.Getenv("WALLETD_API_KEY"))

var transfer walletd.Transfer
err := client.Do(ctx, http.MethodPost, "/v1/transfers", map[string]any{
    "from":     "user-42",
    "to":       "@grace",
    "amount":   2500, // minor units, $25.00, never a float
    "currency": "USD",
}, &transfer, "xfer-ada-grace-001") // idempotency key
if err != nil {
    return fmt.Errorf("transfer: %w", err)
}
client = WalletD()  # reads WALLETD_API / WALLETD_API_KEY

transfer = client.request(
    "POST",
    "/v1/transfers",
    {
        "from": "user-42",
        "to": "@grace",
        "amount": 2500,      # minor units, $25.00
        "currency": "USD",
    },
    idempotency_key="xfer-ada-grace-001",
)
print(transfer["status"])  # "settled"
const res = await fetch(`${API}/v1/transfers`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
    "Idempotency-Key": "xfer-ada-grace-001",
  },
  body: JSON.stringify({
    from: "user-42",
    to: "@grace",
    amount: 2500, // minor units, $25.00
    currency: "USD",
  }),
});
const transfer = await res.json();
$transfer = $walletd->request('POST', '/v1/transfers', [
    'from'     => 'user-42',
    'to'       => '@grace',
    'amount'   => 2500,      // minor units, $25.00
    'currency' => 'USD',
], idempotencyKey: 'xfer-ada-grace-001');

echo $transfer['status']; // "settled"
var body = Map.of(
    "from", "user-42",
    "to", "@grace",
    "amount", 2500,      // minor units, $25.00
    "currency", "USD");

Transfer transfer = client.post(
    "/v1/transfers", body, "xfer-ada-grace-001", Transfer.class);

Des principes qui tiennent à chaque étape

Idempotent par défaut

Chaque appel de mouvement d'argent prend une clé d'idempotence. Les nouvelles tentatives sont sûres ; le registre rejoue le résultat stocké octet par octet.

Équilibré en une seule transaction

Frais, blocages, plafonds et reprises sont appliqués à l'intérieur de la même écriture, si bien que les livres ne sont jamais brièvement faux.

Confirmé, pas supposé

L'argent bouge sur confirmation vérifiée de la passerelle et se règle dans le registre, pas sur une réponse client optimiste.

Vérifié en continu

Un vérificateur planifié recalcule la conservation, les soldes et les planchers, et échoue bruyamment dès que quoi que ce soit dérive.

Accès anticipé

Devenez partenaire de conception.

Nous travaillons avec un petit nombre d'équipes qui construisent des produits de portefeuille et de paiement sur WalletD. Si c'est votre cas, parlons-en. Vous aurez un accès direct aux personnes qui l'ont conçu.

Réserver une démoLire la documentation