Pause and resume your business

Every business you run on Checkout has one subscription contract per chain, the SubscriptionManager. That contract has an emergency brake. While it is paused, the contract rejects new subscriptions, charges, and your cancellations. Your customers can still cancel their own subscription. Your other subscribers stay exactly as they were.

Two keys can pull the brake. Your pause authority, the address you declared in Settings → Pause authority before the contract was deployed, can pause and resume. It is fixed when the contract is deployed and can never be changed. If you lose the pause authority key while your business is paused, nobody can resume it. Exodus can pause your business as an incident response, but can never resume it. Resuming is always your decision.

This guide shows what a pause does, what your integration sees, and how to pause and resume without writing code. Pick the option that matches the wallet your pause authority lives in.

What a pause does

The pause is per chain. A business live on five chains has five contracts, and each one is paused and resumed on its own. Pause every chain your business runs on, in any order.

What your integration sees

Every subscription call that needs the contract answers the same way while it is paused:

Treat subscription_manager_paused as a state of your business on that chain, not as a transient error. Retrying does not help until the contract is resumed. Stop the retries for that chain, keep the charge for later, and alert whoever holds the pause authority. If nobody on your team paused, Exodus did; contact support before resuming.

There is no webhook for a pause or a resume. A pause produces no events of its own. Customers can still cancel during a pause, so expect subscription.cancelled events. Events for earlier charges, settlement updates and webhook retries also keep arriving; keep processing them.

Before you start

You need three things.

1. The pause authority wallet. The address shown under Settings → Pause authority in your dashboard, or returned by GET /settings/pauser. A hardware wallet or a Safe is the recommended home for it.
2. Gas on each chain. The wallet pays a small network fee per pause and per resume, in the chain’s native token: ETH on Ethereum, Arbitrum One and Base, POL on Polygon, BNB on BNB Smart Chain. A few dollars’ worth per chain is enough.
3. Your contract addresses. Call GET /settings and read subscription_managers. One entry per chain, the chain in CAIP-2 form:

"subscription_managers": [
  { "chain": "eip155:1",     "address": "0x9a1b2c3d4e5f60718293a4b5c6d7e8f901234567" },
  { "chain": "eip155:42161", "address": "0x9a1b2c3d4e5f60718293a4b5c6d7e8f901234567" },
  { "chain": "eip155:137",   "address": "0x9a1b2c3d4e5f60718293a4b5c6d7e8f901234567" },
  { "chain": "eip155:56",    "address": "0x9a1b2c3d4e5f60718293a4b5c6d7e8f901234567" },
  { "chain": "eip155:8453",  "address": "0x9a1b2c3d4e5f60718293a4b5c6d7e8f901234567" }
]

The address is usually the same on every chain, but always read it per chain. A test business lists its testnet contracts instead (eip155:11155111 for Sepolia, eip155:421614 for Arbitrum Sepolia). There is no testnet contract for BNB Smart Chain, so a test business tests on Sepolia or Arbitrum Sepolia.

Each chain has a block explorer where you can operate the contract from a browser:

Option A: from the block explorer

Use this when the pause authority is a wallet you can connect to a website: a browser wallet, or a hardware wallet through one. No code, no command line.

1. Open the explorer for the chain and paste the contract address in the search box.
2. Open the Contract tab, then Write as Proxy. The contract is a lightweight copy of a shared implementation, so the explorer shows its functions under the proxy tabs.
3. Click Connect to Web3 and connect the pause authority wallet. The explorer shows the connected address; check it matches your pause authority.
4. Find pause in the list and click Write. The function takes no arguments.
5. Confirm the transaction in your wallet. On a hardware wallet, confirm on the device.
6. Wait for the transaction to confirm. The explorer links to it.
7. Repeat on every chain your business runs on.

If the Write as Proxy tab is missing, the explorer has not recognized the implementation yet. Use option B or C instead; the contract itself is the same.

Option B: from a Safe

Use this when the pause authority is a Safe (multisig). Each owner signs from their own wallet, and the last signature executes.

1. Open the Safe app on the right chain, then New transaction → Transaction Builder.
2. Paste the contract address. If the Safe does not load the functions on its own, open Enter ABI and paste this:

[
  {
    "type": "function",
    "name": "pause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "unpause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "paused",
    "inputs": [],
    "outputs": [{ "type": "bool" }],
    "stateMutability": "view"
  }
]

3. Pick pause in the contract method list, leave the value at 0, and click Add transaction, then Create Batch and Send Batch.
4. Review the transaction: the recipient is your contract, the method is pause, the value is 0. Sign it.
5. The other owners sign the same transaction from their wallets until the Safe’s threshold is reached. The last one executes it. The owner who executes pays the gas from their own wallet, not from the Safe, so that owner needs gas on that chain.
6. Repeat on every chain your business runs on. Each chain has its own Safe queue.

Option C: from the command line

Use this when an engineer holds the pause authority key or a hardware wallet with Foundry  installed.

cast send <CONTRACT_ADDRESS> "pause()" --rpc-url <RPC_URL> --ledger

Replace --ledger with --trezor, or with --private-key <KEY> for a software key, and run it once per chain with that chain’s RPC URL. If the pause authority is not the first account on your hardware wallet, add --mnemonic-index <N> and check the address with cast wallet address --ledger --mnemonic-index <N> first.

Confirm the pause

Read the contract state; do not test with a live charge, which would debit a real subscriber if the pause did not land or went to the wrong contract.

• On the explorer, open Contract → Read as Proxy and query paused. It returns true.
• From the command line: cast call <CONTRACT_ADDRESS> "paused()(bool)" --rpc-url <RPC_URL>.

Once it reads true, any POST /subscriptions/{id}/charge on that chain answers 503 with code: subscription_manager_paused. Keep that check for the rehearsal on your test business.

Resume

Resuming is the same procedure with unpause instead of pause, from the pause authority wallet, on every chain you paused. Only the pause authority can unpause. After it confirms, paused reads false and charges go through again.

After you resume, you can charge each subscription up to its budget for the current billing window. A window that passed entirely during the pause can’t be charged afterwards; its budget does not carry over. Checkout does not charge on its own, so charges resume when your scheduler next calls charge.

Rehearse on your test business

Run the full cycle once on your test business before each new business goes live. It costs nothing, and it proves the pause authority key is reachable and the procedure works under no pressure.

Use a test subscription whose current window has budget left for two more charges, and fetch a fresh charge quote before each charge.

1. Charge the test subscription on Sepolia. It succeeds.
2. Pause the Sepolia contract with the pause authority wallet, and confirm paused reads true.
3. Charge again. The API answers 503 subscription_manager_paused.
4. Resume the contract, and confirm paused reads false.
5. Charge again. It succeeds.