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. Aucune de ces étapes n'est facturée à l'usage : WalletD est un prix mensuel fixe, pas des frais par appel ou par transaction.

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.

Transfert entre utilisateurs sandbox approvisionnés

Transfert entre utilisateurs sandbox approvisionnés

Prérequis : deux utilisateurs du même tenant, des fonds de test confirmés et une clé transfers:write. Réutilisez la même clé et le même contenu lors des reprises.

# Existing sandbox users; sender funding must already be confirmed.
# Save this JSON with the business operation. Retry with the same key and body.
curl --fail-with-body -sS -X POST "$WALLETD_API/v1/transfers" \
  -H "Authorization: Bearer $WALLETD_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $TRANSFER_KEY" \
  -d '{"from_user":"0191c2d5-2b18-7e63-8f4a-05c7b9d1e832","to_user":"0191c2d4-8f3a-7c51-9b2e-4a6f8d310e27","amount":2500}'
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/google/uuid"
	"github.com/walletd-io/walletd-go"
)

// Prerequisites: two existing sandbox users in the same tenant, a funded sender,
// and a key with transfers:write. Complete processor confirmation before this call.
func main() {
	client, err := walletd.New(os.Getenv("WALLETD_API"), walletd.APIKey(os.Getenv("WALLETD_API_KEY")))
	if err != nil {
		log.Fatal(err)
	}
	from, err := uuid.Parse(os.Getenv("FROM_USER_ID"))
	if err != nil {
		log.Fatal(err)
	}
	to, err := uuid.Parse(os.Getenv("TO_USER_ID"))
	if err != nil {
		log.Fatal(err)
	}
	// Persist this operation key with the business operation. Reuse it on retries.
	key := walletd.IdempotencyKey(os.Getenv("TRANSFER_KEY"))
	if key == "" {
		log.Fatal("TRANSFER_KEY is required")
	}
	transfer, err := client.CreateTransfer(context.Background(), key, walletd.CreateTransferRequest{
		FromUser: from, ToUser: &to, Amount: 2500, // integer minor units
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(transfer.Id, transfer.Status)
}
# Python standard library; existing funded sandbox users.
import json, os, urllib.request
payload = {"from_user":"0191c2d5-2b18-7e63-8f4a-05c7b9d1e832","to_user":"0191c2d4-8f3a-7c51-9b2e-4a6f8d310e27","amount":2500}
request = urllib.request.Request(os.environ['WALLETD_API'] + '/v1/transfers',
    data=json.dumps(payload).encode(), method='POST', headers={
        'Authorization': 'Bearer ' + os.environ['WALLETD_API_KEY'],
        'Content-Type': 'application/json',
        'Idempotency-Key': os.environ['TRANSFER_KEY'],
    })
with urllib.request.urlopen(request, timeout=30) as response:
    print(json.load(response))
// Node.js HTTP; never put a tenant API key in a browser.
const response = await fetch(process.env.WALLETD_API + '/v1/transfers', {
  method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30000),
  headers: {
    Authorization: 'Bearer ' + process.env.WALLETD_API_KEY,
    'Content-Type': 'application/json',
    'Idempotency-Key': process.env.TRANSFER_KEY,
  },
  body: JSON.stringify({"from_user":"0191c2d5-2b18-7e63-8f4a-05c7b9d1e832","to_user":"0191c2d4-8f3a-7c51-9b2e-4a6f8d310e27","amount":2500}),
});
if (!response.ok) throw new Error('Transfer HTTP ' + response.status);
console.log(await response.json());
<?php
// PHP cURL; existing funded sandbox users.
$ch = curl_init(getenv('WALLETD_API') . '/v1/transfers');
curl_setopt_array($ch, [CURLOPT_POST => true, CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 30, CURLOPT_FOLLOWLOCATION => false,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('WALLETD_API_KEY'),
    'Content-Type: application/json', 'Idempotency-Key: ' . getenv('TRANSFER_KEY')],
  CURLOPT_POSTFIELDS => '{"from_user":"0191c2d5-2b18-7e63-8f4a-05c7b9d1e832","to_user":"0191c2d4-8f3a-7c51-9b2e-4a6f8d310e27","amount":2500}',
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($body === false || $status < 200 || $status >= 300) {
  throw new RuntimeException('Transfer request failed');
}
echo $body;
// Java 17+ HTTP; existing funded sandbox users.
import java.net.URI;
import java.net.http.*;
import java.time.Duration;

class TransferExample {
  public static void main(String[] args) throws Exception {
    var client = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NEVER).build();
    var request = HttpRequest.newBuilder(URI.create(System.getenv("WALLETD_API") + "/v1/transfers"))
      .timeout(Duration.ofSeconds(30))
      .header("Authorization", "Bearer " + System.getenv("WALLETD_API_KEY"))
      .header("Content-Type", "application/json")
      .header("Idempotency-Key", System.getenv("TRANSFER_KEY"))
      .POST(HttpRequest.BodyPublishers.ofString("""
        {"from_user":"0191c2d5-2b18-7e63-8f4a-05c7b9d1e832","to_user":"0191c2d4-8f3a-7c51-9b2e-4a6f8d310e27","amount":2500}
        """)).build();
    var response = client.send(request, HttpResponse.BodyHandlers.ofString());
    if (response.statusCode() < 200 || response.statusCode() >= 300) throw new Exception("Transfer failed");
    System.out.println(response.body());
  }
}

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.

Du déploiement aux opérations quotidiennes.

Un partenaire pour tout le cycle de vie, avec un périmètre convenu et des responsabilités claires.

Planifier et déployer

Architecture, environnements, configuration et planification des versions avec votre équipe.

Personnaliser

Adaptez la marque, les parcours et les règles métier au produit que vous souhaitez créer.

Exploiter et faire évoluer

Assistance, maintenance et mises à niveau, avec procédures d’escalade et niveaux de service définis par contrat.

Explore managed services (English) →

Prix fixe, sans frais par transaction

Voyez-le tourner avec vos chiffres.

Apportez un cas, de l'encaissement au versement. En 30 minutes, vous le verrez comptabilisé, rapproché et chiffré, avec l'ingénieur qui l'a construit.