SDK setup

Install an official SDK (Node, Python, or Go), configure it, and make your first signed call.

The official SDKs are the fastest way to integrate: they sign every request for you (HMAC over the canonical string — see Authentication), raise typed, retry-friendly errors, and track the API contract. Prefer raw HTTPS? Every guide also shows the equivalent signed curl.

All SDKs are server-side only — your API key and signing secret must never reach a browser.

Choose your language

Full, per-endpoint API reference for each SDK:

Node.jsNode reference →

PythonPython reference →

GoGo reference →

Don't see your language or framework? Request an SDK → — Node, Python, and Go ship today; tell us what to build next.

Install

npm install absolutepay

Requires Node 18+ (uses the global fetch and node:crypto).

pip install absolutepay

Requires Python 3.9+. Zero runtime dependencies — standard library only.

go get github.com/AbsolutePay/absolutepay-go

Requires Go 1.18+.

Configure

import { AbsolutePay } from "absolutepay";

const ap = new AbsolutePay({
  apiKey: process.env.ABSOLUTEPAY_API_KEY!,            // ap_live_… / ap_test_…
  signingSecret: process.env.ABSOLUTEPAY_SIGNING_SECRET!, // apisign_… — required for app keys
  // sandbox: true,            // → https://sandbox-api.absolutepay.io (default: production)
  // baseUrl: "https://…",     // optional, overrides `sandbox` entirely
  // timeoutMs: 30000,         // per-request timeout (default 30s)
});

import os
from absolutepay import AbsolutePay

ap = AbsolutePay(
    api_key=os.environ["ABSOLUTEPAY_API_KEY"],               # ap_live_… / ap_test_…
    signing_secret=os.environ["ABSOLUTEPAY_SIGNING_SECRET"], # apisign_… — required for app keys
    # sandbox=True,          # → https://sandbox-api.absolutepay.io (default: production)
    # base_url="https://…",  # optional, overrides `sandbox` entirely
    # timeout=30.0,          # per-request timeout in seconds (default 30)
)

import (
	"os"

	"github.com/AbsolutePay/absolutepay-go"
)

ap, err := absolutepay.New(
	os.Getenv("ABSOLUTEPAY_API_KEY"),            // ap_live_… / ap_test_…
	absolutepay.WithSigningSecret(os.Getenv("ABSOLUTEPAY_SIGNING_SECRET")), // apisign_…
	// absolutepay.WithSandbox(true),            // → https://sandbox-api.absolutepay.io
)

Option	Required	Default	Notes
`apiKey` / `api_key`	yes	—	The app's bearer token (`ap_live_` or `ap_test_`).
`signingSecret` / `signing_secret`	yes for app keys	—	The `apisign_` secret. The SDK signs every request with it.
`sandbox`	no	`false`	`true` → the dedicated sandbox host. Ignored if a base URL is set.
`baseUrl` / `base_url`	no	production	Override the API origin entirely.
`timeoutMs` / `timeout`	no	30s	Aborts a request after this long (ms in Node, seconds in Python).

Keep secrets in env vars

Never hard-code the API key or signing secret. Load them from the environment (or a secrets manager) so they never land in your repo or a browser bundle.

First call

Read your balances — the simplest call to confirm your key + signing work:

const balances = await ap.balances.list();
console.log(balances); // [{ currency: "USDT", available: "1000.000000", locked: "0.000000" }]

balances = ap.balances.list()
print(balances)  # [{"currency": "USDT", "available": "1000.000000", "locked": "0.000000"}]

balances, err := ap.Balances.List(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Println(balances) // []absolutepay.Balance{{USDT 1000.000000 0.000000}}

# sign() emits the three signing headers — see the Authentication guide for the helper.
curl https://api.absolutepay.io/v1/balances \
  -H "Authorization: Bearer $APP_TOKEN" $(sign GET /v1/balances "")

A test workspace starts with sandbox funds, so you'll see a balance right away.

Handle errors

Non-2xx responses raise AbsolutePayError with the platform's problem fields:

import { AbsolutePay, AbsolutePayError } from "absolutepay";

try {
  await ap.payouts.create({ items: [/* … */] });
} catch (e) {
  if (e instanceof AbsolutePayError) {
    console.error(e.status, e.code, e.title, e.detail, e.requestId);
    if (e.isRateLimited) { /* back off and retry */ }
    if (e.isAuth) { /* check key / scopes / signature */ }
  }
}

from absolutepay import AbsolutePayError

try:
    ap.payouts.create([...])
except AbsolutePayError as e:
    print(e.status, e.code, e.detail, e.request_id)
    if e.is_rate_limited:  # back off and retry
        ...
    if e.is_auth:          # check key / scopes / signature
        ...

_, err := ap.Payouts.Create(ctx, []absolutepay.PayoutItem{/* … */})

var apErr *absolutepay.Error
if errors.As(err, &apErr) {
	fmt.Println(apErr.Status, apErr.Code, apErr.Detail, apErr.RequestID)
	if apErr.IsRateLimited() { /* back off and retry */ }
	if apErr.IsAuth() { /* check key / scopes / signature */ }
}

See Error handling for the retry strategy and the full error shape.

Low-level escape hatch

Every resource method wraps a low-level request(...) that signs and sends for you. Use it directly for any endpoint without a dedicated helper:

const data = await ap.request("GET", "/v1/reconciliation/payments?limit=50");

data = ap.request("GET", "/v1/reconciliation/payments?limit=50")

// The Go client is fully typed — use the resource method, e.g.
page, err := ap.Reconciliation.Payments(ctx, absolutepay.ReconciliationQuery{Limit: 50})
if err != nil {
	log.Fatal(err)
}
fmt.Println(page)

Or: install the agent skill

If you build with an AI coding agent (Claude Code, Cursor, or anything that supports skills), you can skip the manual wiring entirely — install the official AbsolutePay skill and let your agent do the integration:

npx skills add AbsolutePay/absolutepay-skill

The skill teaches your agent to integrate AbsolutePay via these SDKs (or raw REST) with the guardrails built in — request signing, webhook verification on the raw body, and idempotent event handling. To also pull the bundled reference files, run npx github:AbsolutePay/absolutepay-skill.

Quickstart — create your first payment end to end.
Authentication — keys, signing, and scopes (what the SDK does for you).
API reference — every endpoint, parameters, and responses. Also the generated SDK references: Node.js · Python · Go.