subscription.prepareCharge - Base Documentation

import { base } from '@base-org/account';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base as baseChain } from 'viem/chains';

// Initialize wallet client with your subscription owner account
const account = privateKeyToAccount('0x...'); // Your app's private key
const walletClient = createWalletClient({
  account,
  chain: baseChain,
  transport: http()
});

// Prepare to charge a specific amount
const chargeCalls = await base.subscription.prepareCharge({
  id: '0x71319cd488f8e4f24687711ec5c95d9e0c1bacbf5c1064942937eba4c7cf2984',
  amount: '9.99',
  testnet: false
});

// Execute each charge call
const transactionHashes = [];

for (const call of chargeCalls) {
  const hash = await walletClient.sendTransaction({
    to: call.to,
    data: call.data,
    value: call.value || 0n
  });
  
  transactionHashes.push(hash);
  
  // Wait for transaction confirmation before next call
  await walletClient.waitForTransactionReceipt({ hash });
}

console.log(`Charge transactions: ${transactionHashes.join(', ')}`);

import { base } from '@base-org/account';
import { createPublicClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base as baseChain } from 'viem/chains';
import { toCoinbaseSmartAccount, createBundlerClient } from 'viem/account-abstraction';

// Create public client
const publicClient = createPublicClient({
  chain: baseChain,
  transport: http()
});

// Convert private key to owner account
const owner = privateKeyToAccount('0x...'); // Your app's private key

// Create a Coinbase Smart Wallet account from the owner
const smartAccount = await toCoinbaseSmartAccount({
  client: publicClient,
  owners: [owner],
  version: '1'
});

// Create bundler client for sending UserOperations
const bundlerClient = createBundlerClient({
  account: smartAccount,
  chain: baseChain,
  client: publicClient,
  transport: http('your-bundler-url') // Your bundler URL
});

// Prepare to charge the maximum available amount
const chargeCalls = await base.subscription.prepareCharge({
  id: subscriptionId,
  amount: 'max-remaining-charge',
  testnet: false
});

// Send UserOperation through bundler
const userOpHash = await bundlerClient.sendUserOperation({
  calls: chargeCalls
});

// Wait for the UserOperation to be included
const receipt = await bundlerClient.waitForUserOperationReceipt({
  hash: userOpHash
});

console.log(`Charge bundled in transaction: ${receipt.receipt.transactionHash}`);

[
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0x095ea7b3...",
    value: "0x0"
  },
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0xa9059cbb...",
    value: "0x0"
  }
]

[
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0xa9059cbb...",
    value: "0x0"
  }
]

Defined in the Base Account SDK

Most developers should use charge() instead, which handles execution automatically using CDP wallets. This function is for advanced use cases requiring custom transaction handling.

The prepareCharge function prepares the necessary transaction calls to charge a subscription. It returns the array of call data objects to execute the charge through wallet_sendCalls or eth_sendTransaction. This gives you programmatic control over when and how to execute subscription charges.

When to Use This

Use prepareCharge only if you need:

Custom wallet infrastructure (not using CDP)
Manual transaction control
Integration with existing wallet systems
Client-side charging (though this is uncommon)

For standard backend subscription management, use charge() instead.

Parameters

string

required

The subscription ID (permission hash) returned from subscribe().Pattern: ^0x[0-9a-fA-F]{64}$

amount

string | 'max-remaining-charge'

required

Amount to charge (e.g., “10.50”) or ‘max-remaining-charge’ for the full remaining amount in the current period.

testnet

boolean

Must match the testnet setting used in the original subscribe call. Default: false

Returns

result

PrepareChargeResult

Array of transaction calls to execute the charge.

Show PrepareChargeResult properties

Address

The address to call (smart contract address).

data

Hex

The encoded call data for the transaction.

value

'0x0'

The value to send (always 0x0 for spend permissions).

The returned array contains:

An approval call (if the permission is not yet active)
A spend call to charge the subscription

import { base } from '@base-org/account';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base as baseChain } from 'viem/chains';

// Initialize wallet client with your subscription owner account
const account = privateKeyToAccount('0x...'); // Your app's private key
const walletClient = createWalletClient({
  account,
  chain: baseChain,
  transport: http()
});

// Prepare to charge a specific amount
const chargeCalls = await base.subscription.prepareCharge({
  id: '0x71319cd488f8e4f24687711ec5c95d9e0c1bacbf5c1064942937eba4c7cf2984',
  amount: '9.99',
  testnet: false
});

// Execute each charge call
const transactionHashes = [];

for (const call of chargeCalls) {
  const hash = await walletClient.sendTransaction({
    to: call.to,
    data: call.data,
    value: call.value || 0n
  });
  
  transactionHashes.push(hash);
  
  // Wait for transaction confirmation before next call
  await walletClient.waitForTransactionReceipt({ hash });
}

console.log(`Charge transactions: ${transactionHashes.join(', ')}`);

import { base } from '@base-org/account';
import { createPublicClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base as baseChain } from 'viem/chains';
import { toCoinbaseSmartAccount, createBundlerClient } from 'viem/account-abstraction';

// Create public client
const publicClient = createPublicClient({
  chain: baseChain,
  transport: http()
});

// Convert private key to owner account
const owner = privateKeyToAccount('0x...'); // Your app's private key

// Create a Coinbase Smart Wallet account from the owner
const smartAccount = await toCoinbaseSmartAccount({
  client: publicClient,
  owners: [owner],
  version: '1'
});

// Create bundler client for sending UserOperations
const bundlerClient = createBundlerClient({
  account: smartAccount,
  chain: baseChain,
  client: publicClient,
  transport: http('your-bundler-url') // Your bundler URL
});

// Prepare to charge the maximum available amount
const chargeCalls = await base.subscription.prepareCharge({
  id: subscriptionId,
  amount: 'max-remaining-charge',
  testnet: false
});

// Send UserOperation through bundler
const userOpHash = await bundlerClient.sendUserOperation({
  calls: chargeCalls
});

// Wait for the UserOperation to be included
const receipt = await bundlerClient.waitForUserOperationReceipt({
  hash: userOpHash
});

console.log(`Charge bundled in transaction: ${receipt.receipt.transactionHash}`);

[
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0x095ea7b3...",
    value: "0x0"
  },
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0xa9059cbb...",
    value: "0x0"
  }
]

[
  {
    to: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    data: "0xa9059cbb...",
    value: "0x0"
  }
]

Error Handling

try {
  const chargeCalls = await base.subscription.prepareCharge({
    id: subscriptionId,
    amount: chargeAmount,
    testnet: false
  });
  // Execute charge
} catch (error) {
  console.error(`Failed to prepare charge: ${error.message}`);
}

Comparison with charge()

Using prepareCharge (Advanced)
Using charge() (Recommended)

// You manage everything manually
const chargeCalls = await base.subscription.prepareCharge({
  id: subscriptionId,
  amount: 'max-remaining-charge',
  testnet: false
});

// Initialize wallet client
const walletClient = createWalletClient({
  account: privateKeyToAccount('0x...'),
  chain: baseChain,
  transport: http()
});

// Execute each call sequentially
for (const call of chargeCalls) {
  const hash = await walletClient.sendTransaction({
    to: call.to,
    data: call.data,
    value: call.value || 0n
  });
  
  await walletClient.waitForTransactionReceipt({ hash });
}

// Handle gas estimation, nonce management, retries, etc.

// Everything handled automatically
const result = await base.subscription.charge({
  id: subscriptionId,
  amount: 'max-remaining-charge',
  testnet: false
});

// Done! CDP wallet handles:
// - Wallet initialization
// - Transaction signing
// - Gas estimation
// - Nonce management
// - Call batching
// - Transaction confirmation
// - Optional paymaster support

console.log(`Charged: ${result.id}`);

Migration to charge()

If you’re currently using prepareCharge in a Node.js backend, consider migrating to charge():

Before (prepareCharge)

// Old approach - manual execution
const chargeCalls = await base.subscription.prepareCharge({
  id: subscriptionId,
  amount: '9.99',
  testnet: false
});

const walletClient = createWalletClient({
  account: privateKeyToAccount(process.env.PRIVATE_KEY),
  chain: baseChain,
  transport: http()
});

const transactionHashes = [];
for (const call of chargeCalls) {
  const hash = await walletClient.sendTransaction({
    to: call.to,
    data: call.data,
    value: call.value || 0n
  });
  
  transactionHashes.push(hash);
  await walletClient.waitForTransactionReceipt({ hash });
}

After (charge)

// New approach - automatic execution with CDP
const result = await base.subscription.charge({
  id: subscriptionId,
  amount: '9.99',
  testnet: false
});

console.log(`Charged: ${result.id}`);

Charge

Automatic charging with CDP

Check Status

Verify subscription before charging

Custom Revoke

Advanced revoke execution

subscription.getOrCreateSubscriptionOwnerWallet

subscription.prepareRevoke

⌘I

​When to Use This

​Parameters

​Returns

​Error Handling

​Comparison with charge()

​Migration to charge()

​Related Functions

Charge

Check Status

Custom Revoke

When to Use This

Parameters

Returns

Error Handling

Comparison with charge()

Migration to charge()

Related Functions