Polymarket Deposit Wallet (2026): How It Works and the API

What is a Polymarket Deposit Wallet?

Polymarket's docs call it "the default smart wallet for trading on Polymarket." It holds your pUSD and outcome tokens, while a separate key, the signer, authorizes everything the wallet does. "All Polymarket account wallets deployed on or after May 4, 2026 use it." If the split between signer and wallet is new to you, start with the Polymarket proxy wallet guide, because querying the signer instead of the wallet is the most common integration mistake.

How is a Deposit Wallet different from proxy and Safe wallets?

The biggest practical difference is who signs. On a Proxy or Safe order, the maker is the wallet and the signer is your key. On a Deposit Wallet order, both fields carry the wallet address, and your key's signature over the order is wrapped for ERC-7739 validation so the wallet contract can verify it. The unified SDKs handle that wrapping, and older clients called this signature type POLY_1271.

Deposit Wallets also get session keys. An owner can authorize a separate signer to trade on the CLOB, Combos or all venues for 180 days unless revoked, and Polymarket's docs say a session key "cannot withdraw funds from the Deposit Wallet." Session keys are in beta, and authorizing one needs a Builder API key.

What is the Deposit Wallet factory?

The Deposit Wallet Factory at 0x00000000000Fb5C9ADea0298D729A0CB3823Cc07 on Polygon deploys every Deposit Wallet, and the Deposit Wallet Beacon at 0x7A18EDfe055488A3128f01F563e5B479D92ffc3a points new wallets at their implementation. Deployment goes through the relayer as a WALLET-CREATE request from the signer to the factory, authorized with a Builder API key. The confirmed relayer transaction returns the new wallet as proxyAddress. With the SDK you rarely do this by hand, because createSecureClient with a Builder API key and no wallet derives the address and deploys the wallet when needed.

The proxy pattern changed on 29 June 2026. Wallets deployed before that use a UUPS proxy, and wallets deployed after it use an ERC-1967 beacon proxy, which lets Polymarket ship implementation upgrades without changing any wallet's address. An owner can opt out by calling pause(), waiting the factory's timelockDelay(), calling optOut() and then unpause(). Those are direct transactions that need POL for gas, and Polymarket warns that an opted-out wallet stops receiving security fixes delivered through the beacon.

How do you find a user's Deposit Wallet address?

There are four reliable ways, depending on what you already hold:

• The profile menu. polymarket.com shows the account wallet address there.
• The SDK. After createSecureClient, client.account.wallet holds it and client.account.walletType is 3. In Python, read client.wallet and client.wallet_type.
• The deployment record. A confirmed WALLET-CREATE transaction carries it as proxyAddress.
• Derivation. The address is a deterministic CREATE2 result from the factory, the beacon and the signer, so you can compute it before the wallet exists.

This implements Polymarket's documented derivation with viem, then asks the relayer whether the wallet is deployed:

import { concat, encodeAbiParameters, getContractAddress, keccak256, pad, toHex, type Address } from 'viem';

const FACTORY = '0x00000000000Fb5C9ADea0298D729A0CB3823Cc07';
const BEACON = '0x7A18EDfe055488A3128f01F563e5B479D92ffc3a';

// Polymarket's documented CREATE2 derivation for a beacon-proxy Deposit Wallet
function depositWalletAddress(signer: Address): Address {
  const args = encodeAbiParameters(
    [{ type: 'address' }, { type: 'bytes32' }],
    [FACTORY, pad(signer, { size: 32 })],
  );
  const argsLength = BigInt((args.length - 2) / 2);
  const initCodeHash = keccak256(concat([
    toHex(0x6100523d8160233d3973n + (argsLength << 56n), { size: 10 }),
    BEACON,
    '0x60195155f3363d3d373d3d363d602036600436635c60da',
    '0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c',
    '0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3',
    args,
  ]));
  return getContractAddress({ opcode: 'CREATE2', from: FACTORY, salt: keccak256(args), bytecodeHash: initCodeHash });
}

const wallet = depositWalletAddress('0xYOUR_SIGNER_ADDRESS');
const res = await fetch(`https://relayer-v2.polymarket.com/deployed?address=${wallet}&type=WALLET`);
console.log(wallet, await res.json());

How do gasless WALLET batches go through the relayer?

A Deposit Wallet "executes one or more contract calls as an ordered batch." The owner signs the whole batch once, and the relayer submits it, so the wallet never needs POL for gas. The flow has five steps:

1. Build the calls. Each call has a target contract, a value in wei of POL, usually "0", and ABI-encoded data.
2. Fetch a nonce. GET /v1/account/transactions/params?address=SIGNER&type=WALLET on relayer-v2.polymarket.com, with your Relayer or Builder API key headers.
3. Sign the batch. Sign EIP-712 Batch typed data in the DepositWallet domain, version 1, chain 137, with the wallet as the verifying contract.
4. Submit. Send POST /submit with type WALLET, the signer as from, the factory as to, and the calls in depositWalletParams.
5. Confirm. Poll GET /v1/account/transactions/{id} until STATE_CONFIRMED, and treat STATE_FAILED and STATE_INVALID as final.

import { privateKeyToAccount } from 'viem/accounts';

const RELAYER = 'https://relayer-v2.polymarket.com';
const FACTORY = '0x00000000000Fb5C9ADea0298D729A0CB3823Cc07';
const headers = {
  'Content-Type': 'application/json',
  RELAYER_API_KEY: process.env.RELAYER_API_KEY!,
  RELAYER_API_KEY_ADDRESS: process.env.RELAYER_API_KEY_ADDRESS!,
};
const signer = privateKeyToAccount(process.env.SIGNER_PRIVATE_KEY as `0x${string}`);
const wallet = process.env.DEPOSIT_WALLET_ADDRESS as `0x${string}`;
const calls: { target: `0x${string}`; value: string; data: `0x${string}` }[] = [
  { target: '0xCONTRACT_ADDRESS', value: '0', data: '0xENCODED_CALLDATA' },
];

// 1. Fetch a fresh WALLET nonce for the signer
const params = await fetch(`${RELAYER}/v1/account/transactions/params?address=${signer.address}&type=WALLET`, { headers });
const { nonce } = (await params.json()) as { nonce: string };

// 2. Sign the Batch with the signer that controls the Deposit Wallet
const deadline = String(Math.floor(Date.now() / 1000) + 600);
const signature = await signer.signTypedData({
  domain: { name: 'DepositWallet', version: '1', chainId: 137, verifyingContract: wallet },
  types: {
    Call: [{ name: 'target', type: 'address' }, { name: 'value', type: 'uint256' }, { name: 'data', type: 'bytes' }],
    Batch: [{ name: 'wallet', type: 'address' }, { name: 'nonce', type: 'uint256' }, { name: 'deadline', type: 'uint256' }, { name: 'calls', type: 'Call[]' }],
  },
  primaryType: 'Batch',
  message: {
    wallet,
    nonce: BigInt(nonce),
    deadline: BigInt(deadline),
    calls: calls.map((c) => ({ target: c.target, value: BigInt(c.value), data: c.data })),
  },
});

// 3. Submit it, then poll /v1/account/transactions/{id} until STATE_CONFIRMED
const submit = await fetch(`${RELAYER}/submit`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    type: 'WALLET',
    from: signer.address,
    to: FACTORY,
    nonce,
    signature,
    metadata: 'Approve pUSD',
    depositWalletParams: { depositWallet: wallet, deadline, calls },
  }),
});
const { transactionID } = (await submit.json()) as { transactionID: string };
console.log(transactionID);

How do you migrate to a Deposit Wallet?

For an account, there is no documented switch yet. Existing Proxy and Safe wallets keep working as legacy types, and Polymarket's session key docs say "a dedicated migration flow from Safe Wallets and Proxy Wallets is planned," without a date. Until then, an account's wallet type is set by when and how it was created.

For code, the migration is to the unified SDK. Older clients reached a Deposit Wallet with signatureType: POLY_1271 plus a funder address. createSecureClient({ wallet, signer }) replaces that, and leaving out wallet uses the default Deposit Wallet flow. The old relayer client's deployDepositWallet() becomes createSecureClient with a Builder API key. Rust users on polymarket_client_sdk_v2, which Polymarket's guide pins at 0.7.0, can trade from an existing Deposit Wallet with SignatureType::Poly1271, but deploying wallets and submitting batches stays on the API flow above.

Where does Predictefy fit?

Keeping the keys with the account owner is the same principle Predictefy follows. The Predictefy API builds orders server side across 15+ venues, and you sign them in your own wallet or process, so Predictefy never holds your funds or keys. Paper trading costs 0 credits on every plan, which lets you rehearse an order flow before real funds move. Trading involves risk, and a dry run catches setup mistakes before they cost money.

Frequently Asked Questions