Le mouvement de l'argent, à l'altitude d'un appel REST.

Cinq appels vous mènent de bout en bout : créer un utilisateur, alimenter un portefeuille, vérifier le solde, envoyer de l'argent, lire l'historique. Dix minutes avec une clé sandbox. Les clés sandbox ne déplacent aucun argent réel.

SDK Go ou simple HTTP

Utilisez le SDK Go publié, générez un client typé à partir des contrats OpenAPI, ou appelez l'API depuis n'importe quelle bibliothèque HTTP. Aucun environnement d'exécution propriétaire.

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.

Des événements dignes de confiance

Les webhooks sont signés en HMAC-SHA256 avec une fenêtre de rejeu, livrés au moins une fois avec des ids de déduplication, sur un pool de workers isolé des parcours monétaires.

Identifiants à portée limitée

Clés d'API de tenant pour le serveur à serveur, jetons utilisateur signés à courte durée de vie pour les appels client, jetons du personnel pour les opérations, vérifiés à chaque requête.

Alimentez un portefeuille, puis envoyez de l'argent

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());
  }
}

Webhooks

Vérifiez en quelques lignes.

Chaque événement est signé. Rejetez tout ce qui ne se vérifie pas à temps constant, et dédupliquez sur l'id de l'événement. Recevoir deux fois le même événement est attendu et sans risque.

Tous les types d'événements
// Pseudocode: use the verified webhook receiver in the documentation.
// Verify timestamp freshness and HMAC over timestamp + "." + raw request bytes.
// Use constant-time comparison. Reject before accepting any event identity.
// Deduplicate using the event id inside the VERIFIED body, not an unsigned header.
// Persist to an inbox before returning success; process asynchronously.
// See https://docs.walletd.io/webhooks for executable receivers.

Prix fixe, sans frais par transaction

Obtenez une clé sandbox.

Chaque évaluation reçoit un tenant sandbox, les contrats OpenAPI, le SDK Go et une ligne directe vers les ingénieurs qui l'ont construit. La production est à prix mensuel fixe, sans frais par transaction.