Plan & deploy
Architecture, environment setup, configuration and release planning, aligned with your team.
WalletD is a REST API in front of a ledger of record. Here is the path a single payment takes, from onboarding a user to a movement your auditors can recompute. None of these steps is metered: WalletD is a flat monthly price, not a fee per call or per transaction.
How it works
Create a wallet user with your own external id. WalletD opens accounts per purpose (cash, points) the first time each is used, so there is nothing to provision up front.
Start a top-up through Stripe. The balance is credited only when the gateway confirms with a signed webhook or a reconciliation query, never on a client callback.
Send peer-to-peer, take a payment with a hold, or split a marketplace sale. Every call carries an idempotency key and posts balanced legs to the ledger in one transaction.
Cashback and points are granted at the moment of capture; fees and commission are split; payouts produce a settlement statement. All of it posts to the same books.
Read balances and history over the API, receive signed webhooks for every event, and let the built-in verifier re-check the ledger's invariants on a schedule.
Transfer between funded sandbox users
Prerequisites: two existing users in the same tenant, confirmed test funding and a key with transfers:write. Use the same operation key and body on retries.
# 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());
}
}Every money-moving call takes an idempotency key. Retries are safe; the ledger replays the stored result byte-for-byte.
Fees, holds, caps, and clawbacks are applied inside the same posting, so the books are never briefly wrong.
Money moves on verified gateway confirmation and settles on the ledger, not on an optimistic client response.
A scheduled verifier recomputes conservation, balances, and floors, and fails loudly the moment anything drifts.
A delivery partner for the whole lifecycle, with an agreed scope and clear responsibilities.
Architecture, environment setup, configuration and release planning, aligned with your team.
Customize branding, workflows and business rules around the product you want to build.
Ongoing support, maintenance and upgrades, with escalation paths and service levels defined in your agreement.
Flat price, no per-transaction fee
Bring one collection-to-payout case. In 30 minutes you will see it posted, reconciled and priced, with the engineer who built it.