Gasless Transactions

Polymarket’s Relayer Client enables gasless transactions for your users. Instead of requiring users to hold POL for gas, Polymarket’s infrastructure pays all transaction fees. This creates a seamless experience where users only need USDC.e to trade.

How It Works

The relayer acts as a transaction sponsor:

Your app creates a transaction
The user signs it with their private key
Your app sends it to Polymarket’s relayer
The relayer submits it onchain and pays the gas fee
The transaction executes from the user’s wallet

Gasless transactions require Builder Program membership. You’ll need Builder API credentials to authenticate with the relayer.

What Is Covered

Polymarket pays gas for all operations routed through the relayer:

Operation	Description
Wallet deployment	Deploy Safe or Proxy wallets for new users
Token approvals	Approve contracts to spend USDC.e or outcome tokens
CTF operations	Split, merge, and redeem positions
Transfers	Move tokens between addresses

Prerequisites

Before using the relayer, you need:

Requirement	Source
Builder API credentials	Builder Profile
User’s private key or signer	Your wallet integration
USDC.e balance	For trading (not for gas)

Installation

npm install @polymarket/builder-relayer-client @polymarket/builder-signing-sdk

Client Setup

Initialize the relayer client with your signing configuration:

Local Signing
Remote Signing

Use local signing when your backend handles all transactions securely.

import { createWalletClient, http, Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { polygon } from "viem/chains";
import { RelayClient } from "@polymarket/builder-relayer-client";
import { BuilderConfig } from "@polymarket/builder-signing-sdk";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const wallet = createWalletClient({
  account,
  chain: polygon,
  transport: http(process.env.RPC_URL),
});

const builderConfig = new BuilderConfig({
  localBuilderCreds: {
    key: process.env.POLY_BUILDER_API_KEY!,
    secret: process.env.POLY_BUILDER_SECRET!,
    passphrase: process.env.POLY_BUILDER_PASSPHRASE!,
  },
});

const client = new RelayClient(
  "https://relayer-v2.polymarket.com/",
  137,
  wallet,
  builderConfig,
);

Use remote signing to keep credentials on a secure server you control.Your signing server receives request details and returns authentication headers:

import {
  buildHmacSignature,
  BuilderApiKeyCreds,
} from "@polymarket/builder-signing-sdk";

const BUILDER_CREDENTIALS: BuilderApiKeyCreds = {
  key: process.env.POLY_BUILDER_API_KEY!,
  secret: process.env.POLY_BUILDER_SECRET!,
  passphrase: process.env.POLY_BUILDER_PASSPHRASE!,
};

// POST /sign endpoint
export async function handleSignRequest(request) {
  const { method, path, body } = await request.json();
  const timestamp = Date.now().toString();

  const signature = buildHmacSignature(
    BUILDER_CREDENTIALS.secret,
    parseInt(timestamp),
    method,
    path,
    body,
  );

  return {
    POLY_BUILDER_SIGNATURE: signature,
    POLY_BUILDER_TIMESTAMP: timestamp,
    POLY_BUILDER_API_KEY: BUILDER_CREDENTIALS.key,
    POLY_BUILDER_PASSPHRASE: BUILDER_CREDENTIALS.passphrase,
  };
}

Your client points to your signing server:

import { RelayClient } from "@polymarket/builder-relayer-client";
import { BuilderConfig } from "@polymarket/builder-signing-sdk";

const builderConfig = new BuilderConfig({
  remoteBuilderConfig: {
    url: "https://your-server.com/sign",
  },
});

const client = new RelayClient(
  "https://relayer-v2.polymarket.com/",
  137,
  wallet,
  builderConfig,
);

Never expose Builder API credentials in client-side code. Use environment variables or a secrets manager.

Relayer Authentication Headers

All requests to the relayer must include these authentication headers:

Header	Description
`POLY_BUILDER_API_KEY`	Your Builder API key
`POLY_BUILDER_TIMESTAMP`	Unix timestamp
`POLY_BUILDER_PASSPHRASE`	Your Builder passphrase
`POLY_BUILDER_SIGNATURE`	HMAC-SHA256 signature

The SDKs handle header generation automatically when you provide your credentials via BuilderConfig.

Wallet Types

Choose a wallet type when initializing the client:

Type	Deployment	Best For
Safe	Call `deploy()` before first transaction	Most builder integrations
Proxy	Auto-deploys on first transaction	Magic Link users

import { RelayClient, RelayerTxType } from "@polymarket/builder-relayer-client";

const client = new RelayClient(
  "https://relayer-v2.polymarket.com/",
  137,
  wallet,
  builderConfig,
  RelayerTxType.SAFE,
);

// Deploy before first transaction
const response = await client.deploy();
const result = await response.wait();
console.log("Safe Address:", result?.proxyAddress);

Executing Transactions

Use the execute method to send transactions through the relayer:

interface Transaction {
  to: string; // Target contract address
  data: string; // Encoded function call
  value: string; // POL to send (usually "0")
}

const response = await client.execute(transactions, "Description");
const result = await response.wait();

Token Approval

Approve contracts to spend tokens:

import { encodeFunctionData, maxUint256 } from "viem";

const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
const CTF = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";

const approveTx = {
  to: USDC,
  data: encodeFunctionData({
    abi: [
      {
        name: "approve",
        type: "function",
        inputs: [
          { name: "spender", type: "address" },
          { name: "amount", type: "uint256" },
        ],
        outputs: [{ type: "bool" }],
      },
    ],
    functionName: "approve",
    args: [CTF, maxUint256],
  }),
  value: "0",
};

const response = await client.execute([approveTx], "Approve USDC.e for CTF");
await response.wait();

Redeem Positions

Exchange winning tokens for USDC.e after market resolution:

import { encodeFunctionData } from "viem";

const redeemTx = {
  to: CTF_ADDRESS,
  data: encodeFunctionData({
    abi: [
      {
        name: "redeemPositions",
        type: "function",
        inputs: [
          { name: "collateralToken", type: "address" },
          { name: "parentCollectionId", type: "bytes32" },
          { name: "conditionId", type: "bytes32" },
          { name: "indexSets", type: "uint256[]" },
        ],
        outputs: [],
      },
    ],
    functionName: "redeemPositions",
    args: [collateralToken, parentCollectionId, conditionId, indexSets],
  }),
  value: "0",
};

const response = await client.execute([redeemTx], "Redeem positions");
await response.wait();

Batch Transactions

Execute multiple operations atomically in a single call:

const approveTx = {
  to: USDC,
  data: encodeFunctionData({
    abi: erc20Abi,
    functionName: "approve",
    args: [CTF, maxUint256],
  }),
  value: "0",
};

const transferTx = {
  to: USDC,
  data: encodeFunctionData({
    abi: erc20Abi,
    functionName: "transfer",
    args: [recipientAddress, parseUnits("50", 6)],
  }),
  value: "0",
};

// Both execute atomically
const response = await client.execute(
  [approveTx, transferTx],
  "Approve and transfer",
);
await response.wait();

Batching reduces latency and ensures all transactions succeed or fail together.

Transaction States

Track transaction progress through these states:

State	Terminal	Description
`STATE_NEW`	No	Transaction received by relayer
`STATE_EXECUTED`	No	Submitted onchain
`STATE_MINED`	No	Included in a block
`STATE_CONFIRMED`	Yes	Finalized successfully
`STATE_FAILED`	Yes	Failed permanently
`STATE_INVALID`	Yes	Rejected as invalid

Getting Started

Core Concepts

Market Data

Trading

Market Makers

Builder Program

Resources

How It Works

What Is Covered

Prerequisites

Installation

Client Setup

Relayer Authentication Headers

Wallet Types

Executing Transactions

Token Approval

Redeem Positions

Batch Transactions

Transaction States

Contract Addresses

Resources

Next Steps

Negative Risk Markets

Positions & Tokens

Getting Started

Core Concepts

Market Data

Trading

Market Makers

Builder Program

Resources

​How It Works

​What Is Covered

​Prerequisites

​Installation

​Client Setup

​Relayer Authentication Headers

​Wallet Types

​Executing Transactions

​Token Approval

​Redeem Positions

​Batch Transactions

​Transaction States

​Contract Addresses

​Resources

​Next Steps

Negative Risk Markets

Positions & Tokens

How It Works

What Is Covered

Prerequisites

Installation

Client Setup

Relayer Authentication Headers

Wallet Types

Executing Transactions

Token Approval

Redeem Positions

Batch Transactions

Transaction States

Contract Addresses

Resources

Next Steps