Quickstart

From zero to a paid test order in a few minutes — agent skill, SDK, or raw curl.

This walks you from an empty project to a paid test order. All three integration paths work here — pick Node, Python, Go, or curl below and the choice sticks across every guide.

Building with an AI coding agent?

Install the official skill first — npx skills add AbsolutePay/absolutepay-skill — and your agent learns this entire flow (SDK calls, request signing, webhook verification). You can then say "add AbsolutePay checkout to this app" and skim this page as the reference for what it does.

1. Create an app

In the dashboard, go to Developers → Apps and create an app. You'll get three secrets once: the ap_test_… token, an apisign_… signing secret, and (if you set a webhook URL) a whsec_… webhook signing secret. Use the test token while you build.

New apps need approval

A new app starts pending review — an admin must approve it before it can authenticate. To skip the wait, build in the dedicated sandbox (sandbox.absolutepay.io, API at https://sandbox-api.absolutepay.io), where apps are auto-approved.

2. Install the SDK

The SDKs sign every request for you, raise typed errors, and paginate lists. Going raw REST instead? Nothing to install — you'll sign each request yourself.

npm install absolutepay

pip install absolutepay

go get github.com/AbsolutePay/absolutepay-go

# No SDK — export your secrets and grab the sign() shell helper
# from the Authentication guide; every curl sample below uses it.
export APP_TOKEN="ap_test_…"
export SIGNING_SECRET="apisign_…"

Export your secrets as ABSOLUTEPAY_API_KEY and ABSOLUTEPAY_SIGNING_SECRET (the samples below read them from the environment). See SDK setup for full configuration options.

3. Confirm your credentials

Read your balances. With the SDK, signing is automatic; with curl you sign each request (see Authentication for the sign() helper).

import { AbsolutePay } from "absolutepay";

const ap = new AbsolutePay({
  apiKey: process.env.ABSOLUTEPAY_API_KEY!,        // ap_test_…
  signingSecret: process.env.ABSOLUTEPAY_SIGNING_SECRET!,
  // sandbox: true,  // if you're on the dedicated sandbox
});

console.log(await ap.balances.list());

import os
from absolutepay import AbsolutePay

ap = AbsolutePay(
    api_key=os.environ["ABSOLUTEPAY_API_KEY"],        # ap_test_…
    signing_secret=os.environ["ABSOLUTEPAY_SIGNING_SECRET"],
    # sandbox=True,  # if you're on the dedicated sandbox
)

print(ap.balances.list())

ap, err := absolutepay.New(
	os.Getenv("ABSOLUTEPAY_API_KEY"),        // ap_test_…
	absolutepay.WithSigningSecret(os.Getenv("ABSOLUTEPAY_SIGNING_SECRET")),
	// absolutepay.WithSandbox(true),
)
if err != nil {
	log.Fatal(err)
}
ctx := context.Background()

balances, err := ap.Balances.List(ctx)
if err != nil {
	log.Fatal(err)
}
fmt.Println(balances)

curl https://api.absolutepay.io/v1/balances \
  -H "Authorization: Bearer $APP_TOKEN" $(sign GET /v1/balances "")

{ "items": [{ "currency": "USDT", "available": "1000.000000", "locked": "0.000000" }] }

A test workspace starts with sandbox funds, so you'll see a balance immediately. Every list endpoint returns this { items, nextCursor } shape — see Pagination.

4. Create a payment

Create a checkout and send your customer to the returned checkoutUrl (they pick the asset on the page). reference is your order id — keep it unique per order; it's also how you poll status later. Amounts are decimal strings ("10.00"), never floats.

const checkout = await ap.checkouts.create({
  reference: "order-1024",                        // your order id
  amount: { amount: "10.00", currency: "USDT" },
});
console.log(checkout.token, checkout.checkoutUrl);

checkout = ap.checkouts.create(
    reference="order-1024",                          # your order id
    amount={"amount": "10.00", "currency": "USDT"},
)
print(checkout["token"], checkout["checkoutUrl"])

checkout, err := ap.Checkouts.Create(ctx, absolutepay.CheckoutParams{
	Reference: "order-1024", // your order id
	Amount:    absolutepay.Money{Amount: "10.00", Currency: "USDT"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(checkout.Token, checkout.CheckoutURL)

BODY='{"reference":"order-1024","amount":{"amount":"10.00","currency":"USDT"}}'
curl https://api.absolutepay.io/v1/checkouts \
  -H "Authorization: Bearer $APP_TOKEN" -H "Content-Type: application/json" \
  $(sign POST /v1/checkouts "$BODY") -d "$BODY"

{ "token": "chk_…", "kind": "checkout", "status": "OPEN", "checkoutUrl": "https://pay.absolutepay.io/pay/chk_…" }

5. Watch it get paid

In test mode the order is auto-paid a few moments after creation and a payment.succeeded webhook fires — exactly the flow you'll see in production. On the dedicated sandbox you drive settlement yourself: open the link in the dashboard and hit Simulate payment.

Don't fulfill until the order reaches a terminal paid state. Use the webhook as the primary signal and read the checkout back by its token as a fallback:

const checkout = await ap.checkouts.get("chk_…");
if (checkout.status === "PAID") { /* fulfill */ }

checkout = ap.checkouts.get("chk_…")
if checkout["status"] == "PAID":
    ...  # fulfill

checkout, err := ap.Checkouts.Get(ctx, "chk_…")
if err != nil {
	log.Fatal(err)
}
if checkout.Status == "PAID" {
	// fulfill
}

curl "https://api.absolutepay.io/v1/checkouts/chk_…" \
  -H "Authorization: Bearer $APP_TOKEN" $(sign GET "/v1/checkouts/chk_…" "")

Before you build further

Crypto payments are irreversible — there are no chargebacks, so never fulfill on a redirect, only on PAID. Money-moving POSTs (payouts, refunds, conversions) accept an Idempotency-Key; reuse the same key on retries so a request applies at most once.

6. Go live

Swap the ap_test_ app for an ap_live_ one (re-approved + re-signed) — same base URL, same request shapes. Walk the Go-live checklist first.

Accept payments · Send payouts · Webhooks
SDK setup · Authentication · API reference