<!-- tempo-docs-context -->
> Source: [/docs/guide/payments/send-a-payment/examples](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples.md)
> Section: [Tempo EVM](https://tempo.com/developers/docs/development.md). Build on Tempo EVM: wallets and keys, payments, transactions and fees, TIP-20 Tokens, contracts, exchange, network details, nodes, protocol specifications, and changelog.
> [Documentation index](https://tempo.com/developers/llms.txt) · [Docs skill](https://tempo.com/developers/SKILL.md)

> Tempo MCP: Use `search`, `find_pages`, `read_page`, and `code` at `https://mcp.tempo.xyz` for Tempo and related documentation.
> If an indexed page is missing or reflects an older site, read this site’s [documentation index](https://tempo.com/developers/llms.txt) and Markdown pages directly.

# Payment examples

Use these examples to send AlphaUSD on Moderato testnet. Start with [Send payments](https://tempo.com/developers/docs/guide/payments/send-a-payment) for the integration flow, or [Browser payments](https://tempo.com/developers/docs/guide/payments/send-a-payment/browser) for a complete React walkthrough.

Fund a test account with the [faucet](https://tempo.com/developers/docs/quickstart/faucet) and replace the example recipients with accounts you control. Set `RPC_URL` or `TEMPO_RPC_URL` to `https://rpc.moderato.tempo.xyz` for command-line examples. Use the [SDK guides](https://tempo.com/developers/docs/sdk) to install and configure your language's tooling. Cast examples use `TEMPO_PRIVATE_KEY` from the [CLI setup](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples#cli-client); all token amounts are in base units.

## Send a payment

Send a payment using the standard `transfer` function. The Solidity examples are owner-operated treasury contracts: pass the token address to the constructor and fund the contract before calling it.

### Viem

:::code-group
```ts twoslash [example.ts]
// @noErrors
import { parseUnits } from 'viem'
import { client } from './viem.config'

const { receipt } = await client.token.transferSync({
  amount: parseUnits('100', 6), // 100 tokens (6 decimals) // [!code hl]
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb', // [!code hl]
  token: '0x20c0000000000000000000000000000000000001', // AlphaUSD // [!code hl]
})
```

```ts twoslash [viem.config.ts]
import { tempoModerato } from 'viem/chains'
import { Account, createClient } from 'viem/tempo'

const privateKey = process.env.TEMPO_PRIVATE_KEY
if (!privateKey || !/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error('Set TEMPO_PRIVATE_KEY to your funded test account private key')
}

export const client = createClient({
  account: Account.fromSecp256k1(privateKey as `0x${string}`),
  chain: tempoModerato,
  feeToken: '0x20c0000000000000000000000000000000000001',
})
```
:::

### Wagmi

```tsx twoslash
// @noErrors
import { Hooks } from 'wagmi/tempo'
import { parseUnits } from 'viem'

function SendPayment() {
  const { mutate, isPending } = Hooks.token.useTransferSync() // [!code hl]

  return (
    <button
      onClick={() =>
        mutate({ // [!code hl]
          amount: parseUnits('100', 6), // [!code hl]
          to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb', // [!code hl]
          token: '0x20c0000000000000000000000000000000000001', // [!code hl]
        }) // [!code hl]
      }
      disabled={isPending}
    >
      Send Payment
    </button>
  )
}
```

### Rust

:::code-group
```rust [example.rs]
use alloy::{
    primitives::{address, U256},
    providers::ProviderBuilder,
};
use tempo_alloy::{TempoNetwork, contracts::precompiles::ITIP20};

mod provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = provider::get_provider().await?;

    let token = ITIP20::new( // [!code hl]
        address!("0x20c0000000000000000000000000000000000001"), // AlphaUSD // [!code hl]
        &provider, // [!code hl]
    ); // [!code hl]

    let receipt = token // [!code hl]
        .transfer( // [!code hl]
            address!("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb"), // [!code hl]
            U256::from(100_000_000), // 100 tokens (6 decimals) // [!code hl]
        ) // [!code hl]
        .send() // [!code hl]
        .await? // [!code hl]
        .get_receipt() // [!code hl]
        .await?; // [!code hl]

    println!("Transfer successful: {:?}", receipt.transaction_hash);

    Ok(())
}
```

```rust [provider.rs]
use alloy::providers::ProviderBuilder;
use alloy::signers::local::PrivateKeySigner;
use tempo_alloy::TempoNetwork;

pub async fn get_provider() -> Result<
    impl alloy::providers::Provider<TempoNetwork>,
    Box<dyn std::error::Error>,
> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")
        .expect("PRIVATE_KEY not set")
        .parse()?;

    let provider = ProviderBuilder::new_with_network::<TempoNetwork>()
        .wallet(signer)
        .connect(&std::env::var("RPC_URL").expect("RPC_URL not set"))
        .await?;

    Ok(provider)
}
```
:::

### Python

:::code-group
```python [example.py]
from eth_abi import encode
from pytempo import Call, TempoTransaction
from provider import w3, account

TRANSFER_SELECTOR = bytes.fromhex("a9059cbb")
ALPHA_USD = "0x20c0000000000000000000000000000000000001"

data = TRANSFER_SELECTOR + encode( # [!code hl]
    ["address", "uint256"], # [!code hl]
    ["0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb", 100_000_000], # [!code hl]
) # [!code hl]

tx = TempoTransaction.create(
    chain_id=w3.eth.chain_id,
    gas_limit=100_000,
    max_fee_per_gas=w3.eth.gas_price * 2,
    max_priority_fee_per_gas=w3.eth.gas_price,
    nonce=w3.eth.get_transaction_count(account.address),
    calls=(
        Call.create(to=ALPHA_USD, data="0x" + data.hex()), # [!code hl]
    ),
)

signed_tx = tx.sign(account.key.hex())
tx_hash = w3.eth.send_raw_transaction(signed_tx.encode())
```

```python [provider.py]
from web3 import Web3
from eth_account import Account

w3 = Web3(Web3.HTTPProvider("https://rpc.moderato.tempo.xyz"))
account = Account.from_key("0x...")
```
:::

### Go

:::code-group
```go [main.go]
package main

import (
	"context"
	"log"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/tempoxyz/tempo-go/pkg/signer"
	"github.com/tempoxyz/tempo-go/pkg/transaction"
)

func buildTransferData(to common.Address, amount *big.Int) []byte {
	data := make([]byte, 68) // 4 (selector) + 32 (address) + 32 (uint256)
	data[0], data[1], data[2], data[3] = 0xa9, 0x05, 0x9c, 0xbb
	copy(data[16:36], to.Bytes())
	amount.FillBytes(data[36:68])
	return data
}

func main() {
	sgn, _ := signer.NewSigner("0x...")
	c := newClient()
	ctx := context.Background()

	nonce, _ := c.GetTransactionCount(ctx, sgn.Address().Hex())

	recipient := common.HexToAddress("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb")
	alphaUSD := common.HexToAddress("0x20c0000000000000000000000000000000000001")

    tx := transaction.NewBuilder(big.NewInt(42431)).
		SetNonce(nonce).
		SetGas(100_000).
		SetMaxFeePerGas(big.NewInt(25_000_000_000)).
		SetMaxPriorityFeePerGas(big.NewInt(1_000_000_000)).
		AddCall( // [!code hl]
			alphaUSD, // [!code hl]
			big.NewInt(0), // [!code hl]
			buildTransferData(recipient, big.NewInt(100_000_000)), // [!code hl]
		). // [!code hl]
		Build()

	_ = transaction.SignTransaction(tx, sgn)
	serialized, _ := transaction.Serialize(tx, nil)
	txHash, _ := c.SendRawTransaction(ctx, serialized)

	log.Printf("Transaction hash: %s", txHash)
}
```

```go [provider.go]
package main

import (
	"os"

	"github.com/tempoxyz/tempo-go/pkg/client"
)

func newClient() *client.Client {
	return client.New(os.Getenv("TEMPO_RPC_URL"))
}
```
:::

### Cast

```bash
cast erc20 transfer \
  0x20c0000000000000000000000000000000000001 \
  0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb \
  100000000 \
  --tempo.fee-token 0x20c0000000000000000000000000000000000001 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$TEMPO_PRIVATE_KEY" # [!code hl]
```

### Solidity

```solidity
import {ITIP20} from "tempo-std/interfaces/ITIP20.sol";

contract PaymentSender {
    ITIP20 public immutable token;
    address public immutable owner;

    constructor(ITIP20 token_) {
        token = token_;
        owner = msg.sender;
    }

    function sendPayment(address recipient, uint256 amount) external {
        require(msg.sender == owner, "Only owner");
        token.transfer(recipient, amount); // [!code hl]
    }
}
```

## Add a payment reference

Include a memo for payment reconciliation and tracking. Use a short invoice or order ID. Follow [Payment references](https://tempo.com/developers/docs/guide/payments/transfer-memos#encode-a-payment-reference) for the shared UTF-8 encoding and length checks.

### Viem

:::code-group
```ts twoslash [example.ts]
// @noErrors
import { parseUnits, toHex } from 'viem'
import { client } from './viem.config'

const invoiceId = toHex('INV-12345', { size: 32 }) // [!code hl]

const { receipt } = await client.token.transferSync({
  amount: parseUnits('100', 6),
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
  token: '0x20c0000000000000000000000000000000000001',
  memo: invoiceId, // [!code hl]
})
```

```ts twoslash [viem.config.ts]
import { tempoModerato } from 'viem/chains'
import { Account, createClient } from 'viem/tempo'

const privateKey = process.env.TEMPO_PRIVATE_KEY
if (!privateKey || !/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error('Set TEMPO_PRIVATE_KEY to your funded test account private key')
}

export const client = createClient({
  account: Account.fromSecp256k1(privateKey as `0x${string}`),
  chain: tempoModerato,
  feeToken: '0x20c0000000000000000000000000000000000001',
})
```
:::

### Wagmi

```tsx twoslash
// @noErrors
import { Hooks } from 'wagmi/tempo'
import { parseUnits, toHex } from 'viem'

function SendPaymentWithMemo() {
  const { mutate, isPending } = Hooks.token.useTransferSync()

  return (
    <button
      onClick={() =>
        mutate({
          amount: parseUnits('100', 6),
          to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
          token: '0x20c0000000000000000000000000000000000001',
          memo: toHex('INV-12345', { size: 32 }), // [!code hl]
        })
      }
      disabled={isPending}
    >
      Send Payment
    </button>
  )
}
```

### Rust

:::code-group
```rust [example.rs]
use alloy::{
    primitives::{address, B256, U256},
    providers::ProviderBuilder,
};
use tempo_alloy::{TempoNetwork, contracts::precompiles::ITIP20};

mod provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = provider::get_provider().await?;

    let token = ITIP20::new(
        address!("0x20c0000000000000000000000000000000000001"),
        &provider,
    );

    let receipt = token
        .transferWithMemo( // [!code hl]
            address!("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb"),
            U256::from(100_000_000),
            B256::right_padding_from("INV-12345".as_bytes()), // [!code hl]
        )
        .send()
        .await?
        .get_receipt()
        .await?;

    println!("Transfer successful: {:?}", receipt.transaction_hash);

    Ok(())
}
```

```rust [provider.rs]
use alloy::providers::ProviderBuilder;
use alloy::signers::local::PrivateKeySigner;
use tempo_alloy::TempoNetwork;

pub async fn get_provider() -> Result<
    impl alloy::providers::Provider<TempoNetwork>,
    Box<dyn std::error::Error>,
> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")
        .expect("PRIVATE_KEY not set")
        .parse()?;

    let provider = ProviderBuilder::new_with_network::<TempoNetwork>()
        .wallet(signer)
        .connect(&std::env::var("RPC_URL").expect("RPC_URL not set"))
        .await?;

    Ok(provider)
}
```
:::

### Python

:::code-group
```python [example.py]
from eth_abi import encode
from pytempo import Call, TempoTransaction
from provider import w3, account

TRANSFER_WITH_MEMO_SELECTOR = bytes.fromhex("76a8ee59")
ALPHA_USD = "0x20c0000000000000000000000000000000000001"

memo = b"INV-12345" + b"\x00" * 23  # right-pad to 32 bytes # [!code hl]

data = TRANSFER_WITH_MEMO_SELECTOR + encode( # [!code hl]
    ["address", "uint256", "bytes32"], # [!code hl]
    ["0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb", 100_000_000, memo], # [!code hl]
) # [!code hl]

tx = TempoTransaction.create(
    chain_id=w3.eth.chain_id,
    gas_limit=100_000,
    max_fee_per_gas=w3.eth.gas_price * 2,
    max_priority_fee_per_gas=w3.eth.gas_price,
    nonce=w3.eth.get_transaction_count(account.address),
    calls=(
        Call.create(to=ALPHA_USD, data="0x" + data.hex()),
    ),
)

signed_tx = tx.sign(account.key.hex())
tx_hash = w3.eth.send_raw_transaction(signed_tx.encode())
```

```python [provider.py]
from web3 import Web3
from eth_account import Account

w3 = Web3(Web3.HTTPProvider("https://rpc.moderato.tempo.xyz"))
account = Account.from_key("0x...")
```
:::

### Go

:::code-group
```go [main.go]
package main

import (
	"context"
	"log"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/tempoxyz/tempo-go/pkg/signer"
	"github.com/tempoxyz/tempo-go/pkg/transaction"
)

func buildTransferWithMemoData(to common.Address, amount *big.Int, memo [32]byte) []byte {
	data := make([]byte, 100) // 4 + 32 + 32 + 32
	data[0], data[1], data[2], data[3] = 0x76, 0xa8, 0xee, 0x59
	copy(data[16:36], to.Bytes())
	amount.FillBytes(data[36:68])
	copy(data[68:100], memo[:])
	return data
}

func main() {
	sgn, _ := signer.NewSigner("0x...")
	c := newClient()
	ctx := context.Background()

	nonce, _ := c.GetTransactionCount(ctx, sgn.Address().Hex())

	recipient := common.HexToAddress("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb")
	alphaUSD := common.HexToAddress("0x20c0000000000000000000000000000000000001")

	var memo [32]byte // [!code hl]
	copy(memo[:], []byte("INV-12345")) // [!code hl]

    tx := transaction.NewBuilder(big.NewInt(42431)).
		SetNonce(nonce).
		SetGas(100_000).
		SetMaxFeePerGas(big.NewInt(25_000_000_000)).
		SetMaxPriorityFeePerGas(big.NewInt(1_000_000_000)).
		AddCall( // [!code hl]
			alphaUSD, // [!code hl]
			big.NewInt(0), // [!code hl]
			buildTransferWithMemoData(recipient, big.NewInt(100_000_000), memo), // [!code hl]
		). // [!code hl]
		Build()

	_ = transaction.SignTransaction(tx, sgn)
	serialized, _ := transaction.Serialize(tx, nil)
	txHash, _ := c.SendRawTransaction(ctx, serialized)

	log.Printf("Transaction hash: %s", txHash)
}
```

```go [provider.go]
package main

import (
	"os"

	"github.com/tempoxyz/tempo-go/pkg/client"
)

func newClient() *client.Client {
	return client.New(os.Getenv("TEMPO_RPC_URL"))
}
```
:::

### Cast

```bash
cast send \
  0x20c0000000000000000000000000000000000001 \
  "transferWithMemo(address,uint256,bytes32)" \
  0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb \
  100000000 \
  "$(cast format-bytes32-string "INV-12345")" \
  --tempo.fee-token 0x20c0000000000000000000000000000000000001 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$TEMPO_PRIVATE_KEY" # [!code hl]
```

### Solidity

```solidity
import {ITIP20} from "tempo-std/interfaces/ITIP20.sol";

contract PaymentSender {
    ITIP20 public immutable token;
    address public immutable owner;

    constructor(ITIP20 token_) {
        token = token_;
        owner = msg.sender;
    }

    function sendPaymentWithMemo(
        address recipient,
        uint256 amount,
        bytes32 invoiceId
    ) external {
        require(msg.sender == owner, "Only owner");
        token.transferWithMemo(recipient, amount, invoiceId); // [!code hl]
    }
}
```

## Batch payments

Send several payments as calls in one transaction. If a call reverts, the whole batch reverts. For separate transaction receipts, [send payments in parallel](https://tempo.com/developers/docs/guide/payments/send-parallel-transactions).

### Viem

:::code-group
```ts twoslash [example.ts]
// @noErrors
import { parseUnits } from 'viem'
import { Actions } from 'viem/tempo'
import { client } from './viem.config'

const token = '0x20c0000000000000000000000000000000000001' as const
const payments = [
  { to: '0x742d35cc6634c0532925a3b844bc9e7595f0bebb', amount: parseUnits('100', 6) },
  { to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', amount: parseUnits('50', 6) },
] as const

const calls = payments.map(({ to, amount }) =>
  Actions.token.transfer.call({ token, to, amount }), // [!code hl]
)

await client.sendTransaction({ calls }) // [!code hl]
```

```ts twoslash [viem.config.ts]
import { tempoModerato } from 'viem/chains'
import { Account, createClient } from 'viem/tempo'

const privateKey = process.env.TEMPO_PRIVATE_KEY
if (!privateKey || !/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error('Set TEMPO_PRIVATE_KEY to your funded test account private key')
}

export const client = createClient({
  account: Account.fromSecp256k1(privateKey as `0x${string}`),
  chain: tempoModerato,
  feeToken: '0x20c0000000000000000000000000000000000001',
})
```
:::

### Wagmi

```tsx twoslash
// @noErrors
import { useSendTransactionSync } from 'wagmi'
import { parseUnits } from 'viem'
import { Actions } from 'viem/tempo'

function BatchPayment() {
  const { mutate: sendTransactionSync, isPending } = useSendTransactionSync()

  const token = '0x20c0000000000000000000000000000000000001'

  return (
    <button
      onClick={() =>
        sendTransactionSync({
          calls: [ // [!code hl]
            Actions.token.transfer.call({ // [!code hl]
              token, // [!code hl]
              to: '0x742d35cc6634c0532925a3b844bc9e7595f0bebb', // [!code hl]
              amount: parseUnits('100', 6), // [!code hl]
            }), // [!code hl]
            Actions.token.transfer.call({ // [!code hl]
              token, // [!code hl]
              to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', // [!code hl]
              amount: parseUnits('50', 6), // [!code hl]
            }), // [!code hl]
          ], // [!code hl]
        })
      }
      disabled={isPending}
    >
      Send Batch Payment
    </button>
  )
}
```

### Rust

:::code-group
```rust [example.rs]
use alloy::{
    primitives::{address, Address, U256},
    providers::{Provider, ProviderBuilder},
    sol_types::SolCall,
};
use tempo_alloy::{
    TempoNetwork, contracts::precompiles::ITIP20, primitives::transaction::Call,
    rpc::TempoTransactionRequest,
};

mod provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = provider::get_provider().await?;

    let recipient1 = address!("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb");
    let recipient2 = address!("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
    let token_address: Address = address!("0x20c0000000000000000000000000000000000001");

    let calls = vec![ // [!code hl]
        Call { // [!code hl]
            to: token_address.into(), // [!code hl]
            input: ITIP20::transferCall { // [!code hl]
                to: recipient1, // [!code hl]
                amount: U256::from(100_000_000), // [!code hl]
            } // [!code hl]
            .abi_encode() // [!code hl]
            .into(), // [!code hl]
            value: U256::ZERO, // [!code hl]
        }, // [!code hl]
        Call { // [!code hl]
            to: token_address.into(), // [!code hl]
            input: ITIP20::transferCall { // [!code hl]
                to: recipient2, // [!code hl]
                amount: U256::from(50_000_000), // [!code hl]
            } // [!code hl]
            .abi_encode() // [!code hl]
            .into(), // [!code hl]
            value: U256::ZERO, // [!code hl]
        }, // [!code hl]
    ]; // [!code hl]

    let pending = provider
        .send_transaction(TempoTransactionRequest {
            calls,
            ..Default::default()
        })
        .await?;
    let tx_hash = pending.tx_hash();

    println!("Batch transaction sent: {tx_hash:?}");

    Ok(())
}
```

```rust [provider.rs]
use alloy::providers::ProviderBuilder;
use alloy::signers::local::PrivateKeySigner;
use tempo_alloy::TempoNetwork;

pub async fn get_provider() -> Result<
    impl alloy::providers::Provider<TempoNetwork>,
    Box<dyn std::error::Error>,
> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")
        .expect("PRIVATE_KEY not set")
        .parse()?;

    let provider = ProviderBuilder::new_with_network::<TempoNetwork>()
        .wallet(signer)
        .connect(&std::env::var("RPC_URL").expect("RPC_URL not set"))
        .await?;

    Ok(provider)
}
```
:::

### Python

:::code-group
```python [example.py]
from eth_abi import encode
from pytempo import Call, TempoTransaction
from provider import w3, account

TRANSFER_SELECTOR = bytes.fromhex("a9059cbb")
ALPHA_USD = "0x20c0000000000000000000000000000000000001"

def build_transfer(to: str, amount: int) -> str:
    data = TRANSFER_SELECTOR + encode(
        ["address", "uint256"], [to, amount]
    )
    return "0x" + data.hex()

tx = TempoTransaction.create(
    chain_id=w3.eth.chain_id,
    gas_limit=200_000,
    max_fee_per_gas=w3.eth.gas_price * 2,
    max_priority_fee_per_gas=w3.eth.gas_price,
    nonce=w3.eth.get_transaction_count(account.address),
    calls=( # [!code hl]
        Call.create( # [!code hl]
            to=ALPHA_USD, # [!code hl]
            data=build_transfer("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb", 100_000_000), # [!code hl]
        ), # [!code hl]
        Call.create( # [!code hl]
            to=ALPHA_USD, # [!code hl]
            data=build_transfer("0x70997970C51812dc3A010C7d01b50e0d17dc79C8", 50_000_000), # [!code hl]
        ), # [!code hl]
    ), # [!code hl]
)

signed_tx = tx.sign(account.key.hex())
tx_hash = w3.eth.send_raw_transaction(signed_tx.encode())
```

```python [provider.py]
from web3 import Web3
from eth_account import Account

w3 = Web3(Web3.HTTPProvider("https://rpc.moderato.tempo.xyz"))
account = Account.from_key("0x...")
```
:::

### Go

:::code-group
```go [main.go]
package main

import (
	"context"
	"log"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/tempoxyz/tempo-go/pkg/signer"
	"github.com/tempoxyz/tempo-go/pkg/transaction"
)

func buildTransferData(to common.Address, amount *big.Int) []byte {
	data := make([]byte, 68)
	data[0], data[1], data[2], data[3] = 0xa9, 0x05, 0x9c, 0xbb
	copy(data[16:36], to.Bytes())
	amount.FillBytes(data[36:68])
	return data
}

func main() {
	sgn, _ := signer.NewSigner("0x...")
	c := newClient()
	ctx := context.Background()

	nonce, _ := c.GetTransactionCount(ctx, sgn.Address().Hex())

	recipient1 := common.HexToAddress("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb")
	recipient2 := common.HexToAddress("0x70997970C51812dc3A010C7d01b50e0d17dc79C8")
	alphaUSD := common.HexToAddress("0x20c0000000000000000000000000000000000001")

    tx := transaction.NewBuilder(big.NewInt(42431)).
		SetNonce(nonce).
		SetGas(200_000).
		SetMaxFeePerGas(big.NewInt(25_000_000_000)).
		SetMaxPriorityFeePerGas(big.NewInt(1_000_000_000)).
		AddCall(alphaUSD, big.NewInt(0), buildTransferData(recipient1, big.NewInt(100_000_000))). // [!code hl]
		AddCall(alphaUSD, big.NewInt(0), buildTransferData(recipient2, big.NewInt(50_000_000))). // [!code hl]
		Build()

	_ = transaction.SignTransaction(tx, sgn)
	serialized, _ := transaction.Serialize(tx, nil)
	txHash, _ := c.SendRawTransaction(ctx, serialized)

	log.Printf("Batch transaction sent: %s", txHash)
}
```

```go [provider.go]
package main

import (
	"os"

	"github.com/tempoxyz/tempo-go/pkg/client"
)

func newClient() *client.Client {
	return client.New(os.Getenv("TEMPO_RPC_URL"))
}
```
:::

### Cast

```bash
cast batch-send \
  --tempo.fee-token 0x20c0000000000000000000000000000000000001 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$TEMPO_PRIVATE_KEY" \
  --call "0x20c0000000000000000000000000000000000001::transfer(address,uint256):0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb,100000000" \
  --call "0x20c0000000000000000000000000000000000001::transfer(address,uint256):0x70997970C51812dc3A010C7d01b50e0d17dc79C8,50000000" # [!code hl]
```

### Solidity

```solidity
import {ITIP20} from "tempo-std/interfaces/ITIP20.sol";

contract BatchPaymentSender {
    ITIP20 public immutable token;
    address public immutable owner;

    constructor(ITIP20 token_) {
        token = token_;
        owner = msg.sender;
    }

    struct Payment {
        address recipient;
        uint256 amount;
    }

    function batchPay(Payment[] calldata payments) external {
        require(msg.sender == owner, "Only owner");
        for (uint256 i = 0; i < payments.length; i++) {
            token.transfer(payments[i].recipient, payments[i].amount); // [!code hl]
        }
    }
}
```

Pass every encoded call together so Tempo executes all transfers in one all-or-nothing transaction.

Check the receipt and transfer events before recording delivery. See [Confirm delivery](https://tempo.com/developers/docs/guide/payments/send-a-payment#confirm-delivery).

<span id="account-example-setup" />

<span id="client-setup" />

## Payment client setup

Configure a client for creating accounts, reading balances, and sending payments. These setups supply the shared configuration used in the payment guides. API examples use Moderato with `chainId=42431`.

### Choose your tools

The examples on this page and in the payment guides use AlphaUSD on Moderato. Choose one signing environment for each workflow: a CLI/private-key signer, a Viem client, or a wallet connected through Wagmi. Read-only examples need no private key.

* [CLI](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples#cli-client): install the current Foundry release with Tempo support.
* [Viem](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples#viem-client): use a local script or backend signer.
* [Wagmi](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples#wagmi-client): connect Tempo Wallet in React.
* [Python](https://tempo.com/developers/docs/guide/payments/send-a-payment/examples#python-client): use the typed Python SDK.

### CLI client

Follow [Foundry installation](https://tempo.com/developers/docs/sdk/foundry#get-started-with-foundry). These examples require a current release with Tempo support, including `cast batch-send` and `cast keychain`.

```bash
export TEMPO_RPC_URL=https://rpc.moderato.tempo.xyz
export ALPHA_USD=0x20c0000000000000000000000000000000000001
export TEMPO_ACCOUNT_ADDRESS=your_test_account_address
export TEMPO_RECIPIENT=your_test_recipient_address
export TEMPO_PRIVATE_KEY=your_test_account_private_key
```

Replace the last three values with your own test inputs. `cast wallet new` creates a local key and address. Keep the private key in your signing environment. A read-only balance query only needs the RPC URL, token, and address. Set `PAYMENT_TX_HASH` to a returned transaction hash when inspecting its receipt.

`cast erc20 transfer` and token amounts in `cast send` or `cast batch-send` use base units: `1000000` is one AlphaUSD. `cast erc20 balance` also returns base units. `cast logs --subscribe` uses the Moderato WebSocket endpoint; stop it with Ctrl+C.

### Wagmi client

Install `wagmi`, `viem`, and `@tanstack/react-query`. Save the network and Tempo Wallet connector configuration:

```ts [wagmi.config.ts]
import { tempoModerato } from 'viem/chains'
import { createConfig, http } from 'wagmi'
import { tempoWallet } from 'wagmi/connectors'

export const config = createConfig({
  connectors: [tempoWallet()],
  chains: [tempoModerato],
  multiInjectedProviderDiscovery: false,
  transports: {
    [tempoModerato.id]: http(),
  },
})

declare module 'wagmi' {
  interface Register { config: typeof config }
}
```

The type registration lets Wagmi accept Tempo transaction fields such as `calls`. Wrap your application in the providers once:

```tsx [App.tsx]
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { WagmiProvider } from 'wagmi'
import { config } from './wagmi.config'
import { Payments } from './Payments'

const queryClient = new QueryClient()
export function App() {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        <Payments />
      </QueryClientProvider>
    </WagmiProvider>
  )
}
```

`Payments` is your React component. Keep imports at module scope and put the short hook examples in its body. Call write handlers such as `sendPayment`, `getTestFunds`, `grantAccess`, and `revokeAccess` only from user actions. Disable buttons while pending or disconnected and display errors. The [complete browser form](https://tempo.com/developers/docs/guide/payments/send-a-payment/browser) shows validation, connection, and receipt states.

Set `alphaUsd` to `0x20c0000000000000000000000000000000000001` and `recipient` to your intended address. Read examples take `account` as an address. The configured connector uses Moderato; keep the connected account on that network.

#### Access-key restrictions

For [granting access](https://tempo.com/developers/docs/accounts/keys#grant-access), use the new P-256 `accessKey` from the [access-key example](https://tempo.com/developers/docs/accounts/access-keys#authorize-a-limited-key). The connected wallet must control the account that key acts for. The official Account Keychain ABI represents the same one-hour, 10 AlphaUSD, recipient-scoped permission as follows:

```ts
const keyRestrictions = {
  expiry: BigInt(Math.floor(Date.now() / 1000) + 3600),
  enforceLimits: true,
  limits: [{ token: alphaUsd, amount: 10_000_000n, period: 0n }],
  allowAnyCalls: false,
  allowedCalls: [{ target: alphaUsd, selectorRules: [{
    selector: '0xa9059cbb', recipients: [recipient],
  }] }],
} as const
```

The raw ABI names the token allowance `amount`; Viem’s helper names it `limit`. In the [Wagmi authorization call](https://tempo.com/developers/docs/accounts/keys#grant-access), `1` identifies the P-256 signature type in `authorizeKey`. Use the actual type of your generated key; secp256k1 is `0`. A connected wallet submits this root-authorized contract call; it does not expose its private key to the application.

### API requests

Get a [Tempo API key](https://tempo.com/developers/docs/api/authentication). Set `TEMPO_API_KEY` and `TEMPO_ACCOUNT_ADDRESS` in your environment. `PAYMENT_TX_HASH` is needed only when reading a specific payment. Keep API keys on your backend.

:::code-group
```ts [TypeScript (fetch)]
const apiHeaders = { 'tempo-api-key': process.env.TEMPO_API_KEY! }
const accountAddress = process.env.TEMPO_ACCOUNT_ADDRESS!
const transactionHash = process.env.PAYMENT_TX_HASH!
if (!apiHeaders['tempo-api-key'] || !accountAddress)
  throw new Error('Set TEMPO_API_KEY and TEMPO_ACCOUNT_ADDRESS')
```

```python [Python]
import os
import requests

api_headers = {"tempo-api-key": os.environ["TEMPO_API_KEY"]}
account_address = os.environ["TEMPO_ACCOUNT_ADDRESS"]
transaction_hash = os.environ.get("PAYMENT_TX_HASH")
```

```bash [cURL (API)]
export TEMPO_API_KEY=your_api_key
export TEMPO_ACCOUNT_ADDRESS=your_account_address
export PAYMENT_TX_HASH=your_transaction_hash
```
:::

Install `requests` with `python -m pip install requests`. Run TypeScript examples in an ESM file such as `example.mts` with `pnpm exec tsx example.mts` after installing `viem` and `tsx`. Replace the shell values with your real inputs. Public reads can support anonymous access; an API key identifies your project's requests and usage.

### Viem client

Install `viem` and `tsx`. Set `TEMPO_PRIVATE_KEY` to your test account key and `TEMPO_RECIPIENT` to an address you control. Fund the signer with the [faucet](https://tempo.com/developers/docs/quickstart/faucet). Save this as `viem.config.ts`:

```ts [viem.config.ts]
import { tempoModerato } from 'viem/chains'
import { Account, createClient } from 'viem/tempo'

const privateKey = process.env.TEMPO_PRIVATE_KEY
if (!privateKey || !/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error('Set TEMPO_PRIVATE_KEY to your funded test account private key')
}

export const client = createClient({
  account: Account.fromSecp256k1(privateKey as `0x${string}`),
  chain: tempoModerato,
  feeToken: '0x20c0000000000000000000000000000000000001',
})
```

Use these imports and inputs before the short payment examples:

```ts [payment.mts]
import { getAddress, toHex } from 'viem'
import { Actions } from 'viem/tempo'
import { client } from './viem.config'

const alphaUsd = '0x20c0000000000000000000000000000000000001'
const recipientInput = process.env.TEMPO_RECIPIENT
if (!recipientInput) throw new Error('Set TEMPO_RECIPIENT')
const recipient = getAddress(recipientInput)
```

Amounts use six decimal places: `1_000_000n` is one AlphaUSD. The client signs with the test account and pays fees in AlphaUSD. A browser uses a wallet client instead of a backend private key.

### Python client

Install the typed SDK with `python -m pip install pytempo==0.6.1 requests`. Set `TEMPO_PRIVATE_KEY`, `TEMPO_RECIPIENT`, and `TEMPO_GAS_LIMIT` before running a payment. The gas limit is your cap for the calls you submit; estimate for your actual transaction instead of assuming every payment has the same cost.

Save this as `payment_setup.py`. It exposes `w3`, `account`, `private_key`, `recipient`, `alpha_usd`, and `transaction_options()` for the examples. The function refreshes the nonce and fee fields each time you build a transaction.

```python [payment_setup.py]
import os
from web3 import Web3
from pytempo import TempoTransaction
from pytempo.contracts import TIP20

w3 = Web3(Web3.HTTPProvider("https://rpc.moderato.tempo.xyz"))
private_key = os.environ["TEMPO_PRIVATE_KEY"]
account = w3.eth.account.from_key(private_key)
recipient = Web3.to_checksum_address(os.environ["TEMPO_RECIPIENT"])
alpha_usd = "0x20c0000000000000000000000000000000000001"

def transaction_options():
    chain_id = w3.eth.chain_id
    if chain_id != 42431:
        raise ValueError("Expected Moderato testnet")
    gas_price = w3.eth.gas_price
    return {
        "chain_id": chain_id,
        "nonce": w3.eth.get_transaction_count(account.address),
        "gas_limit": int(os.environ["TEMPO_GAS_LIMIT"]),
        "max_fee_per_gas": gas_price * 2,
        "max_priority_fee_per_gas": gas_price,
        "fee_token": alpha_usd,
    }
```

Import the setup before a Python payment example:

```python
from payment_setup import (
    w3, account, private_key, recipient, alpha_usd, transaction_options,
)
from pytempo import TempoTransaction
from pytempo.contracts import TIP20
```

`TIP20.transfer` returns a typed call. `TempoTransaction.create` adds transaction fields; `.sign` signs it; `w3.eth.send_raw_transaction` submits the encoded result. To submit the same signed bytes through cURL instead, print `"0x" + signed_tx.encode().hex()` and set `SIGNED_TRANSACTION` to that value. Do not submit both paths unless you intend to rebroadcast the same transaction.

### First payment script

For a complete TypeScript quickstart, save the following as `first-payment.mts` and run `pnpm exec tsx first-payment.mts`. It creates fresh test accounts, requests test funds, transfers one AlphaUSD, and verifies delivery. It needs no API key.

```ts [first-payment.mts]
import { parseEventLogs, parseUnits } from 'viem'
import { generatePrivateKey } from 'viem/accounts'
import { tempoModerato } from 'viem/chains'
import { Abis, Account, createClient } from 'viem/tempo'

const account = Account.fromSecp256k1(generatePrivateKey())
const recipient = Account.fromSecp256k1(generatePrivateKey())
const token = '0x20c0000000000000000000000000000000000001'
const client = createClient({
  account,
  chain: tempoModerato,
  feeToken: token,
})

console.log('Sender:', account.address)
console.log('Recipient:', recipient.address)
await client.faucet.fundSync({ account })

const balance = await client.token.getBalance({ token })
console.log('AlphaUSD balance:', balance.formatted)
const amount = parseUnits('1', 6)
const { receipt } = await client.token.transferSync({
  token,
  to: recipient.address,
  amount,
})
if (receipt.status !== 'success') throw new Error('Transaction failed')

const transfers = parseEventLogs({
  abi: Abis.tip20,
  eventName: 'Transfer',
  logs: receipt.logs.filter((log) => log.address.toLowerCase() === token),
  strict: true,
})
const delivered = transfers.some(
  (transfer) =>
    transfer.args.from.toLowerCase() === account.address.toLowerCase() &&
    transfer.args.to.toLowerCase() === recipient.address.toLowerCase() &&
    transfer.args.amount === amount,
)
if (!delivered) throw new Error('Expected payment was not delivered')

console.log(`Receipt: https://explore.testnet.tempo.xyz/tx/${receipt.transactionHash}`)
```

### Browser wallet setup

Install `accounts@alpha` and `viem`. Save this as `connection.ts`; call `connectAccount` from a user action such as a Connect button. `walletClient` signs with the access key the user approves at sign-in.

```ts [connection.ts]
import { Accounts } from 'accounts'
import { viem } from 'accounts/plugins'
import { tempoModerato } from 'viem/chains'
import { createClient } from 'viem/tempo'

export const accounts = Accounts.create({
  // Each sign-in requests an access key that sends up to 100 AlphaUSD for a day.
  accessKey: () => ({
    expiry: '1d',
    limits: [{ limit: '100', token: 'alphaUSD' }],
  }),
  chain: 'testnet',
  plugins: [viem()],
})

export const walletClient = accounts.viem

export const publicClient = createClient({
  chain: tempoModerato,
})

export async function connectAccount() {
  const session = await accounts.dialog.signIn()
  const address = session.accessKey?.account
  if (!address) throw new Error('No account was selected')
  return address
}
```

For a complete React payment form with loading and error states, follow [Browser payments](https://tempo.com/developers/docs/guide/payments/send-a-payment/browser).

### Passkey creation

Call this function from a user action on localhost or an HTTPS origin. Persist the credential ID and public key in the customer's record so the same passkey can reconnect later.

```ts [create-passkey.ts]
import { Account, WebAuthnP256 } from 'viem/tempo'

export async function createPasskeyAccount() {
  const credential = await WebAuthnP256.createCredential({
    label: 'My Tempo account',
    userId: crypto.getRandomValues(new Uint8Array(32)),
  })
  const account = Account.fromWebAuthnP256(credential)

  return {
    account,
    credential: {
      id: credential.id,
      publicKey: credential.publicKey,
    },
  }
}
```

### Onchain balances and history

Read balances and index account activity directly from the chain. Set `TEMPO_ACCOUNT_ADDRESS` and `TEMPO_FROM_BLOCK` before running `balance.mts`.

```ts [balance.mts]
import { getAddress } from 'viem'
import { tempoModerato } from 'viem/chains'
import { Abis, createClient } from 'viem/tempo'

const accountAddress = process.env.TEMPO_ACCOUNT_ADDRESS
if (!accountAddress) throw new Error('Set TEMPO_ACCOUNT_ADDRESS')

const account = getAddress(accountAddress)
const token = '0x20c0000000000000000000000000000000000001'
const client = createClient({ chain: tempoModerato })

const [balance, { symbol }] = await Promise.all([
  client.token.getBalance({ account, token }),
  client.token.getMetadata({ token }),
])

console.log(`${balance.formatted} ${symbol}`)

const fromBlock = process.env.TEMPO_FROM_BLOCK
if (!fromBlock) throw new Error('Set TEMPO_FROM_BLOCK')

const payments = await client.getContractEvents({
  address: token,
  abi: Abis.tip20,
  eventName: 'Transfer',
  args: { to: account },
  fromBlock: BigInt(fromBlock),
  toBlock: 'latest',
})

console.log(payments.map((payment) => ({
  from: payment.args.from,
  amount: payment.args.amount,
  transactionHash: payment.transactionHash,
  logIndex: payment.logIndex,
})))

const unwatch = client.token.watchTransfer({
  token,
  args: { to: account },
  onTransfer: async (transfer, log) => {
    const balance = await client.token.getBalance({ account, token })
    console.log({
      balance: balance.formatted,
      received: transfer.amount,
      transactionHash: log.transactionHash,
      logIndex: log.logIndex,
    })
  },
})

// Call unwatch() when the application no longer needs the subscription.
```

Call `unwatch()` when the subscription is no longer needed. For indexed reads from any language, use the [interactive API tools](https://tempo.com/developers/docs/guide/payments/accept-a-payment#read-balances).
