Quickstart for Buyers

Prerequisites

Before you begin, ensure you have:

A crypto wallet with USDC (any EVM or SVM compatible wallet)
Node.js and npm, Go, or Python and pip
A service that requires payment via x402

Note
There are pre-configured examples available in the x402 repo, including examples for fetch, Axios, Go, and MCP.

1. Install Dependencies

Node.js
Go
Python

Install the x402 client packages:

# For fetch-based clients
npm install @x402/fetch @x402/evm

# For axios-based clients
npm install @x402/axios @x402/evm

# For Solana support, also add:
npm install @x402/svm

# For Algorand support, also add:
npm install @x402/avm

# For Aptos support, also add:
npm install @x402/aptos

# For Stellar support, also add:
npm install @x402/stellar

# For Keeta support, also add:
npm install @x402/keeta

# For Hedera support, also add:
npm install @x402/hedera

# For Concordium support, also add:
npm install @x402/concordium

# For TON (TVM) support, also add:
npm install @x402/tvm

# For NEAR support, also add:
npm install @x402/near

# For XRPL support, also add:
npm install @x402/xrpl

Add the x402 Go module to your project:

go get github.com/x402-foundation/x402/go/v2

Install the x402 package with your preferred HTTP client:

# For httpx (async) - recommended
pip install "x402[httpx]"

# For requests (sync)
pip install "x402[requests]"

# For Solana support, also add:
pip install "x402[svm]"

# For TON (TVM) support, also add:
pip install "x402[tvm]"

2. Create a Wallet Signer

Node.js (viem)
Go
Python (eth-account)

Install the required package:

npm install viem

Then instantiate the wallet signer:

import { privateKeyToAccount } from "viem/accounts";

// Create a signer from private key (use environment variable)
const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`);

import (
    evmsigners "github.com/x402-foundation/x402/go/v2/signers/evm"
)

// Load private key from environment
evmSigner, err := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))
if err != nil {
    log.Fatal(err)
}

Install the required package:

pip install eth_account

Then instantiate the wallet signer:

import os
from eth_account import Account
from x402.mechanisms.evm import EthAccountSigner

account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
signer = EthAccountSigner(account)

Solana (SVM)

Use SolanaKit to instantiate a signer:

import { createKeyPairSignerFromBytes } from "@solana/kit";
import { base58 } from "@scure/base";

// 64-byte base58 secret key (private + public)
const svmSigner = await createKeyPairSignerFromBytes(
  base58.decode(process.env.SVM_PRIVATE_KEY!)
);

Aptos

Use the Aptos TypeScript SDK to instantiate a signer:

import { Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";

// Create account from private key
const privateKey = new Ed25519PrivateKey(process.env.APTOS_PRIVATE_KEY!);
const aptosSigner = Account.fromPrivateKey({ privateKey });

Algorand (AVM)

Use the @x402/avm package to instantiate a signer:

import { toClientAvmSigner } from "@x402/avm";

// Create signer from Base64-encoded private key (64-byte: seed + pubkey)
const avmSigner = toClientAvmSigner(process.env.AVM_PRIVATE_KEY!);

Stellar

Use the Stellar SDK to instantiate a signer:

import { createEd25519Signer } from "@x402/stellar";

// Create signer from private key (S... format)
const stellarSigner = createEd25519Signer(
  process.env.STELLAR_PRIVATE_KEY!,
  "stellar:testnet"
);

Keeta

Use the Keeta SDK to instantiate a signer:

import * as KeetaNet from "@keetanetwork/keetanet-client";
import { toClientKeetaSigner } from "@x402/keeta";

// Derive account from mnemonic
const account = KeetaNet.lib.Account.fromSeed(
  await KeetaNet.lib.Account.seedFromPassphrase(process.env.KEETA_MNEMONIC!),
  0,
);
const keetaSigner = toClientKeetaSigner(account);

Hedera

Use @x402/hedera to instantiate a signer:

import { createClientHederaSigner } from "@x402/hedera";
import { PrivateKey } from "@hiero-ledger/sdk";

const hederaSigner = createClientHederaSigner(
  process.env.HEDERA_ACCOUNT_ID!,
  PrivateKey.fromStringECDSA(process.env.HEDERA_PRIVATE_KEY!),
  { network: "hedera:testnet" },
);

Concordium

Use @x402/concordium with the Concordium web SDK to instantiate a signer:

import { buildBasicAccountSigner, AccountAddress } from "@concordium/web-sdk";

const concordiumSigner = {
  accountAddress: AccountAddress.fromBase58(process.env.CCD_ADDRESS!),
  signer: buildBasicAccountSigner(process.env.CCD_PRIVATE_KEY!),
};

TON (TVM)

Use @x402/tvm to instantiate a signer:

import { toClientTvmSigner } from "@x402/tvm";
import { mnemonicToPrivateKey } from "@ton/crypto";

const keyPair = await mnemonicToPrivateKey(process.env.TVM_MNEMONIC!.split(" "));
const tvmSigner = toClientTvmSigner(keyPair, {
  network: "tvm:-3",
  apiKey: process.env.TONCENTER_API_KEY,
});

NEAR

Use @x402/near to instantiate a signer:

import { createClientNearSigner } from "@x402/near";

const nearSigner = createClientNearSigner({
  accountId: "alice.testnet",
  secretKey: process.env.NEAR_SECRET_KEY!, // ed25519:... full-access key
});

XRPL

Use @x402/xrpl to instantiate a signer:

import { Wallet } from "xrpl";
import { createXrplWalletSigner } from "@x402/xrpl";

const xrplSigner = createXrplWalletSigner(Wallet.fromSeed(process.env.XRPL_SEED!));

3. Make Paid Requests Automatically

Fetch
Axios
Go
Python (httpx)
Python (requests)

@x402/fetch extends the native fetch API to handle 402 responses and payment headers for you. Full example here

import { wrapFetchWithPayment, x402HTTPClient } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

// Create signer
const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`);

// Create x402 client and register EVM scheme
const client = new x402Client();
client.register("eip155:*", new ExactEvmScheme(signer));

// Wrap fetch with payment handling
const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const httpClient = new x402HTTPClient(client);

// Make request - payment is handled automatically
const response = await fetchWithPayment("https://api.example.com/paid-endpoint", {
  method: "GET",
});

// Parse the payment result (status, body, and decoded payment header)
const result = await httpClient.processResponse(response);
console.log("Response:", result.body);

if (result.paymentStatus === "settled") {
  console.log("Payment settled:", result.header);
} else if (result.paymentStatus === "settle_failed") {
  console.error("Settlement failed:", result.header);
}

@x402/axios adds a payment interceptor to Axios, so your requests are retried with payment headers automatically. Full example here

import { x402Client, wrapAxiosWithPayment, x402HTTPClient } from "@x402/axios";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";
import axios from "axios";

// Create signer
const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`);

// Create x402 client and register EVM scheme
const client = new x402Client();
client.register("eip155:*", new ExactEvmScheme(signer));

// Create an Axios instance with payment handling
const api = wrapAxiosWithPayment(
  axios.create({ baseURL: "https://api.example.com" }),
  client,
);
const httpClient = new x402HTTPClient(client);

// Make request - payment is handled automatically
const response = await api.get("/paid-endpoint");

// Parse the payment result (status, body, and decoded payment header)
const result = httpClient.parsePaymentResult({
  status: response.status,
  getHeader: (name) => response.headers[name.toLowerCase()],
  body: response.data,
});
console.log("Response:", result.body);

if (result.paymentStatus === "settled") {
  console.log("Payment settled:", result.header);
} else if (result.paymentStatus === "settle_failed") {
  console.error("Settlement failed:", result.header);
}

Full example here

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "time"

    x402 "github.com/x402-foundation/x402/go/v2"
    x402http "github.com/x402-foundation/x402/go/v2/http"
    evm "github.com/x402-foundation/x402/go/v2/mechanisms/evm/exact/client"
    evmsigners "github.com/x402-foundation/x402/go/v2/signers/evm"
)

func main() {
    url := "http://localhost:4021/weather"

    // Create EVM signer
    evmSigner, _ := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))

    // Create x402 client and register EVM scheme
    x402Client := x402.Newx402Client().
        Register("eip155:*", evm.NewExactEvmScheme(evmSigner))

    // Wrap HTTP client with payment handling
    httpClient := x402http.WrapHTTPClientWithPayment(
        http.DefaultClient,
        x402http.Newx402HTTPClient(x402Client),
    )

    // Make request - payment is handled automatically
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    // Read response
    var data map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&data)
    fmt.Printf("Response: %+v\n", data)

    // Check payment response header
    paymentHeader := resp.Header.Get("PAYMENT-RESPONSE")
    if paymentHeader != "" {
        fmt.Println("Payment settled successfully!")
    }
}

httpx provides async HTTP client support with automatic 402 payment handling.Full HTTPX example | Full Requests example

import asyncio
import os
from eth_account import Account

from x402 import x402Client
from x402.http import x402HTTPClient
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client


async def main() -> None:
    client = x402Client()
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    http_client = x402HTTPClient(client)

    async with x402HttpxClient(client) as http:
        response = await http.get("https://api.example.com/paid-endpoint")
        await response.aread()

        print(f"Response: {response.text}")

        if response.is_success:
            settle_response = http_client.get_payment_settle_response(
                lambda name: response.headers.get(name)
            )
            print(f"Payment settled: {settle_response}")


asyncio.run(main())

requests provides sync HTTP client support with automatic 402 payment handling.Full Requests example

import os
from eth_account import Account

from x402 import x402ClientSync
from x402.http import x402HTTPClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client


def main() -> None:
    client = x402ClientSync()
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    http_client = x402HTTPClientSync(client)

    with x402_requests(client) as session:
        response = session.get("https://api.example.com/paid-endpoint")

        print(f"Response: {response.text}")

        if response.ok:
            settle_response = http_client.get_payment_settle_response(
                lambda name: response.headers.get(name)
            )
            print(f"Payment settled: {settle_response}")


main()

Multi-Network Client Setup

You can register multiple payment schemes to handle different networks:

TypeScript
Go
Python

import { wrapFetchWithPayment } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { ExactSvmScheme } from "@x402/svm/exact/client";
import { privateKeyToAccount } from "viem/accounts";
import { createKeyPairSignerFromBytes } from "@solana/kit";
import { base58 } from "@scure/base";

// Create signers
const evmSigner = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`);
const svmSigner = await createKeyPairSignerFromBytes(
  base58.decode(process.env.SVM_PRIVATE_KEY!)
);

// Create client with multiple schemes
const client = new x402Client();
client.register("eip155:*", new ExactEvmScheme(evmSigner));
client.register("solana:*", new ExactSvmScheme(svmSigner));

const fetchWithPayment = wrapFetchWithPayment(fetch, client);

// Now handles both EVM and Solana networks automatically!

// For Aptos support, also add:
import { ExactAptosScheme } from "@x402/aptos/exact/client";
import { Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";

const aptosPrivateKey = new Ed25519PrivateKey(process.env.APTOS_PRIVATE_KEY!);
const aptosSigner = Account.fromPrivateKey({ privateKey: aptosPrivateKey });
client.register("aptos:*", new ExactAptosScheme(aptosSigner));

// For Algorand support, also add:
import { ExactAvmScheme, toClientAvmSigner } from "@x402/avm";

const avmSigner = toClientAvmSigner(process.env.AVM_PRIVATE_KEY!);
client.register("algorand:*", new ExactAvmScheme(avmSigner));

// For Stellar support, also add:
import { ExactStellarScheme, createEd25519Signer } from "@x402/stellar";

const stellarSigner = createEd25519Signer(
  process.env.STELLAR_PRIVATE_KEY!,
  "stellar:testnet"
);
client.register("stellar:*", new ExactStellarScheme(stellarSigner));

// For Keeta support, also add:
import * as KeetaNet from "@keetanetwork/keetanet-client";
import { ExactKeetaScheme, toClientKeetaSigner } from "@x402/keeta";

const keetaAccount = KeetaNet.lib.Account.fromSeed(
  await KeetaNet.lib.Account.seedFromPassphrase(process.env.KEETA_MNEMONIC!),
  0,
);
client.register("keeta:*", new ExactKeetaScheme(toClientKeetaSigner(keetaAccount)));

// For Hedera support, also add:
import { ExactHederaScheme } from "@x402/hedera/exact/client";
import { createClientHederaSigner, PrivateKey } from "@x402/hedera";

const hederaSigner = createClientHederaSigner(
  process.env.HEDERA_ACCOUNT_ID!,
  PrivateKey.fromStringECDSA(process.env.HEDERA_PRIVATE_KEY!),
  { network: "hedera:testnet" },
);
client.register("hedera:*", new ExactHederaScheme(hederaSigner));

// For Concordium support, also add:
import { ExactConcordiumScheme } from "@x402/concordium/exact/client";
import { buildBasicAccountSigner, AccountAddress } from "@concordium/web-sdk";

const concordiumSigner = {
  accountAddress: AccountAddress.fromBase58(process.env.CCD_ADDRESS!),
  signer: buildBasicAccountSigner(process.env.CCD_PRIVATE_KEY!),
};
client.register("ccd:*", new ExactConcordiumScheme(concordiumSigner));

// For TON (TVM) support, also add:
import { ExactTvmScheme } from "@x402/tvm/exact/client";
import { toClientTvmSigner } from "@x402/tvm";
import { mnemonicToPrivateKey } from "@ton/crypto";

const tvmKeyPair = await mnemonicToPrivateKey(process.env.TVM_MNEMONIC!.split(" "));
client.register(
  "tvm:*",
  new ExactTvmScheme(
    toClientTvmSigner(tvmKeyPair, {
      network: "tvm:-3",
      apiKey: process.env.TONCENTER_API_KEY,
    }),
  ),
);

// For NEAR support, also add:
import { ExactNearScheme, createClientNearSigner } from "@x402/near";

const nearSigner = createClientNearSigner({
  accountId: "alice.testnet",
  secretKey: process.env.NEAR_SECRET_KEY!, // ed25519:... full-access key
});
client.register("near:*", new ExactNearScheme(nearSigner));

// For XRPL support, also add:
import { Wallet } from "xrpl";
import { createXrplWalletSigner } from "@x402/xrpl";
import { ExactXrplScheme } from "@x402/xrpl/exact/client";

const xrplSigner = createXrplWalletSigner(Wallet.fromSeed(process.env.XRPL_SEED!));
client.register("xrpl:*", new ExactXrplScheme(xrplSigner));

import (
    x402 "github.com/x402-foundation/x402/go/v2"
    x402http "github.com/x402-foundation/x402/go/v2/http"
    evm "github.com/x402-foundation/x402/go/v2/mechanisms/evm/exact/client"
    svm "github.com/x402-foundation/x402/go/v2/mechanisms/svm/exact/client"
    evmsigners "github.com/x402-foundation/x402/go/v2/signers/evm"
    svmsigners "github.com/x402-foundation/x402/go/v2/signers/svm"
)

// Create signers
evmSigner, _ := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))
svmSigner, _ := svmsigners.NewClientSignerFromPrivateKey(os.Getenv("SVM_PRIVATE_KEY"))

// Create client with multiple schemes
x402Client := x402.Newx402Client().
    Register("eip155:*", evm.NewExactEvmScheme(evmSigner)).
    Register("solana:*", svm.NewExactSvmScheme(svmSigner))

// Wrap HTTP client with payment handling
httpClient := x402http.WrapHTTPClientWithPayment(
    http.DefaultClient,
    x402http.Newx402HTTPClient(x402Client),
)

// Now handles both EVM and Solana networks automatically!

import asyncio
import os

from eth_account import Account

from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client
from x402.mechanisms.svm import KeypairSigner
from x402.mechanisms.svm.exact.register import register_exact_svm_client
from x402.mechanisms.tvm import TVM_TESTNET, WalletV5R1Config, WalletV5R1MnemonicSigner
from x402.mechanisms.tvm.exact import ExactTvmClientScheme


async def main() -> None:
    client = x402Client()

    # Register EVM scheme
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    # Register SVM scheme
    svm_signer = KeypairSigner.from_base58(os.getenv("SVM_PRIVATE_KEY"))
    register_exact_svm_client(client, svm_signer)

    # Register TVM scheme
    tvm_config = WalletV5R1Config.from_private_key(TVM_TESTNET, os.getenv("TVM_PRIVATE_KEY"))
    client.register(TVM_TESTNET, ExactTvmClientScheme(WalletV5R1MnemonicSigner(tvm_config)))

    async with x402HttpxClient(client) as http:
        response = await http.get("https://api.example.com/paid-endpoint")
        print(f"Response: {response.text}")


asyncio.run(main())

Spend Controls

By default, the x402 client only pays recognized USD-pegged assets (e.g. USDC) and caps each payment at $1. You can adjust these limits when creating the client:

TypeScript
Go
Python

import { x402Client } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm/exact/client";

const client = x402Client.fromConfig({
  schemes: [
    { network: "eip155:*", client: new ExactEvmScheme(signer) },
  ],
  spendControls: {
    maxAmountPerPayment: "$5",          // raise the USD cap (default: "$1")
    allowedAssets: [
      // opt into a non-default token with an atomic cap
      { network: "eip155:8453", asset: "0xCustomToken", maxAmountPerPayment: "2000000" },
    ],
  },
});

import (
    x402 "github.com/x402-foundation/x402/go/v2"
    evm "github.com/x402-foundation/x402/go/v2/mechanisms/evm/exact/client"
    evmsigners "github.com/x402-foundation/x402/go/v2/signers/evm"
)

evmSigner, _ := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))

client := x402.Newx402Client().
    SetSpendControls(x402.SpendControls{
        MaxAmountPerPayment: "$5", // raise the USD cap (default: "$1")
        AllowedAssets: []x402.SpendControlAsset{
            // opt into a non-default token with an atomic cap
            {Network: "eip155:8453", Asset: "0xCustomToken", MaxAmountPerPayment: "2000000"},
        },
    }).
    Register("eip155:*", evm.NewExactEvmScheme(evmSigner, nil))

// Or disable all spend controls:
// client.DisableSpendControls()

from x402 import x402Client, x402ClientConfig, SchemeRegistration
from x402.mechanisms.evm.exact import ExactEvmScheme
from x402.mechanisms.evm.upto import UptoEvmScheme

client = x402Client.from_config(
    x402ClientConfig(
        schemes=[
            SchemeRegistration(network="eip155:*", client=ExactEvmScheme(signer)),
        ],
        spend_controls={
            "max_amount_per_payment": "$5",  # raise the USD cap (default: "$1")
            "allowed_assets": [
                # opt into a non-default token with an atomic cap
                {"network": "eip155:8453", "asset": "0xCustomToken", "max_amount_per_payment": "2000000"},
            ],
        },
    )
)

Option	TypeScript	Go	Python	Description
Disable all controls	`spendControls: false`	`client.DisableSpendControls()`	`spend_controls=False`	Any asset, no caps.
`maxAmountPerPayment` / `MaxAmountPerPayment` / `max_amount_per_payment`	`"$1"` default	`"$1"` default	`"$1"` default	USD ceiling on recognized USD-pegged assets. Set to `false`/`DisableMaxAmountPerPayment: true`/`False` to remove the cap.
`allowedAssets` / `AllowedAssets` / `allowed_assets`	list or `true`	list or `AllowAnyAsset: true`	list or `True`	Opt into non-default tokens. Omit for default assets only; or a list of `{ network, asset }` entries with an optional atomic per-payment cap.

Spend controls run before any custom policies and before the payment payload is signed. For interactive approval flows (e.g. prompting the user), use onBeforePaymentCreation hooks instead.

Payment Schemes

The examples above use the simplest fixed-price scheme. If a resource advertises a different scheme in its 402 response, register that scheme for the same network namespace:

exact: fixed-price payments.
upto: usage-based payments where you authorize a maximum and the seller charges actual usage.
batch-settlement: high-volume payments where the client deposits into escrow, signs off-chain vouchers, and the seller claims value onchain in batches.

4. Discover Available Services (Optional)

Instead of hardcoding endpoints, you can use the x402 Bazaar to dynamically discover available services. This is especially powerful for building autonomous agents.

// Fetch available services from the Bazaar API
const response = await fetch(
  "https://api.cdp.coinbase.com/platform/v2/x402/discovery/resources"
  // "https://facilitator.payai.network/discovery/resources"  // Bazaar from another facilitator
);
const services = await response.json();

// Filter services by criteria
const affordableServices = services.items.filter((item) =>
  item.accepts.some((req) => Number(req.amount) < 100000) // Under $0.10
);

console.log("Available services:", affordableServices);

Learn more about service discovery in the Bazaar documentation.

5. Error Handling

Clients will throw errors if:

No scheme is registered for the required network
The request configuration is missing
A payment has already been attempted for the request
There is an error creating the payment header

Common error handling:

try {
  const response = await fetchWithPayment(url, { method: "GET" });
  // Handle success
} catch (error) {
  if (error.message.includes("No scheme registered")) {
    console.error("Network not supported - register the appropriate scheme");
  } else if (error.message.includes("Payment already attempted")) {
    console.error("Payment failed on retry");
  } else {
    console.error("Request failed:", error);
  }
}

Summary

Install x402 client packages (@x402/fetch or @x402/axios) and mechanism packages (@x402/evm, @x402/svm, @x402/tvm, @x402/aptos, @x402/keeta, @x402/near, @x402/xrpl)
Create a wallet signer
Create an x402Client and register payment schemes (exact for fixed-price, upto for usage-based billing, batch-settlement for batched EVM micropayments when the server advertises it)
Use the provided wrapper/interceptor to make paid API requests
(Optional) Use the x402 Bazaar to discover services dynamically
Payment flows are handled automatically for you — including upto where you only pay the actual usage

Next Steps:

Explore Advanced Concepts like lifecycle hooks for custom logic before/after verification/settlement
Explore Extensions like Bazaar for service discovery

References:

For questions or support, join our Slack.

Welcome

Getting Started

Core Concepts

Payment Schemes

Extensions

Advanced Concepts

Guides

Developer Tools

SDK Features

Quickstart for Buyers

Prerequisites

1. Install Dependencies

2. Create a Wallet Signer

Solana (SVM)

Aptos

Algorand (AVM)

Stellar

Keeta

Hedera

Concordium

TON (TVM)

NEAR

XRPL

3. Make Paid Requests Automatically

Multi-Network Client Setup

Spend Controls

Payment Schemes

4. Discover Available Services (Optional)

5. Error Handling

Summary

​Prerequisites

​1. Install Dependencies

​2. Create a Wallet Signer

​Solana (SVM)

​Aptos

​Algorand (AVM)

​Stellar

​Keeta

​Hedera

​Concordium

​TON (TVM)

​NEAR

​XRPL

​3. Make Paid Requests Automatically

​Multi-Network Client Setup

​Spend Controls

​Payment Schemes

​4. Discover Available Services (Optional)

​5. Error Handling

​Summary

Prerequisites

1. Install Dependencies

2. Create a Wallet Signer

Solana (SVM)

Aptos

Algorand (AVM)

Stellar

Keeta

Hedera

Concordium

TON (TVM)

NEAR

XRPL

3. Make Paid Requests Automatically

Multi-Network Client Setup

Spend Controls

Payment Schemes

4. Discover Available Services (Optional)

5. Error Handling

Summary