Polymarket Combos (2026): How Parlays and the RFQ API Work

What is a Polymarket Combo?

Polymarket describes Combos as multi-leg positions that combine underlying market outcomes into one YES or NO position. A Combo of YES on market A, YES on B and NO on C pays out only if A and B resolve YES and C resolves NO. Its NO side is the complement and pays if any of those conditions fails. That is the shape of a parlay, although Polymarket's docs never use the word.

Each Combo has its own ERC-1155 YES and NO tokens, fully collateralized in pUSD, but they live on a new Positions Framework rather than the Conditional Tokens Framework. The leg markets keep trading on the CLOB as usual. One risk is worth stating plainly: a YES Combo pays nothing if any single leg loses.

How does Combo pricing work through RFQ?

Pricing runs through a request for quote auction:

1. A user sends an unsigned request with the legs, direction and size.
2. Connected market makers submit signed quotes within a 400-millisecond window.
3. The RFQ system returns the best quote, and the user accepts it by signing the trade before it expires.
4. Makers with Last Look enabled get 1 second to confirm or decline.
5. The trade executes on-chain, both sides get execution updates, and connected makers see a trade broadcast.

Polymarket's overview gives a 10-second acceptance window, while its requester guide says five seconds, so treat each quote's expires_at as the real deadline.

How do you request a Combo quote through the API?

Pick legs from the public catalog, which needs no key. It returns active Combo-enabled markets ordered by volume, up to 100 per page, with position_ids, outcomes and outcome_prices aligned so index 0 is YES and index 1 is NO:

const res = await fetch('https://combos-rfq-api.polymarket.com/v1/rfq/combo-markets?limit=5');
const { markets, next_cursor } = await res.json();

for (const m of markets) {
  const [yesPositionId] = m.position_ids;
  const [yesPrice, noPrice] = m.outcome_prices;
  console.log(m.title, { yesPrice, noPrice, yesPositionId });
}

console.log('next page cursor:', next_cursor);

Requests go to https://combos-rfq-gateway-requester-api.polymarket.com under /v1/requester/rfq, signed with CLOB L2 headers. EOA accounts are rejected, so use a Deposit, Proxy or Safe wallet. A BUY sets a budget including fees, in six-decimal units:

{
  "signer_address": "YOUR_DEPOSIT_WALLET",
  "maker_address": "YOUR_DEPOSIT_WALLET",
  "signature_type": 3,
  "leg_position_ids": ["YES_POSITION_ID_1", "YES_POSITION_ID_2"],
  "direction": "BUY",
  "side": "YES",
  "requested_size": { "unit": "notional", "value_e6": "1000000" }
}

The gateway holds the call until the auction ends, then returns an rfq_id, the winning quote with total_required_e6 and net_receive_e6, and expires_at, or FAILED with NO_QUOTES. You sign an Exchange v3 order from those amounts, send it to /requests/{rfq_id}/accept, then poll until FILLED or CONFIRMED, or a terminal FAILED, EXPIRED or CANCELED. A create that times out has an unknown outcome and no idempotency key, so a blind retry can open a second request. Polymarket lists SDK support for this direct flow as coming soon.

How do market makers quote Combos?

Makers connect to wss://combos-rfq-gateway-quoter.polymarket.com/ws/rfq and must authenticate with CLOB credentials and their wallet identity within 30 seconds. Quotes are priced in pUSD per YES share. A maker can fill a buy-YES request by buying NO at 1 minus the price with collateral, or by selling YES from inventory. We type-checked this TypeScript skeleton against @polymarket/client 0.11.0:

import { createSecureClient, relayerApiKey } from "@polymarket/client";
import type { RfqQuoteRequestEvent } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

// Your pricing model: pUSD per YES share, or undefined to skip the request.
declare function priceCombo(event: RfqQuoteRequestEvent): string | undefined;

const client = await createSecureClient({
  wallet: process.env.POLYMARKET_WALLET_ADDRESS!,
  signer: privateKey(process.env.PRIVATE_KEY!),
  apiKey: relayerApiKey({
    key: process.env.RELAYER_API_KEY!,
    address: process.env.RELAYER_API_KEY_ADDRESS!,
  }),
});

await client.setupTradingApprovals();

async function handleQuoteRequest(event: RfqQuoteRequestEvent) {
  const price = priceCombo(event);
  if (price === undefined) return;
  const ref = await event.quote({ price });
  console.log("quoted", event.rfqId, event.legPositionIds.length, "legs", ref);
}

const session = await client.openRfqSession();

for await (const event of session) {
  if (event.type === "quote_request") void handleQuoteRequest(event);
}

Last Look is offered to makers with about $2,500 in Combo notional volume and an established line of communication with Polymarket, and makers that decline more than 15% of selected quotes over an hour may be paused for a few minutes. Polymarket's own warnings deserve a careful read: same-game legs are often correlated, a thin CLOB midpoint is a poor probability estimate, and 50-50 resolutions change payouts.

Makers who check legs against other venues can pull Polymarket and Kalshi order books from the Predictefy API, in one schema across 15+ venues.

How do Combos work for builders?

Approved builders request and accept Combo quotes for their users through the Builder Gateway, which runs the same auction. In the custodial model, the builder holds users' positions in one omnibus Deposit Wallet. In the non-custodial model, each user signs for their own Deposit Wallet while the builder's server signs its part through remoteBuilderSigning(), so the Builder API secret never reaches the browser. The SDK methods are requestComboQuote(), acceptComboQuote() and waitForComboFill(). Builder attribution only works through this gateway: the requester gateway rejects a non-zero builder field with BUILDER_ATTRIBUTION_NOT_ALLOWED.

What is Combo collateral return?

Quoting Combos can lock pUSD across related positions until every leg resolves. Collateral return finds positions that offset each other, merges the complementary exposure back into pUSD at 1 pUSD per matched share, and leaves the unmatched exposure in residual positions. The flow is plan-based: call planCollateralReturn(), inspect netPusdOut and the position summary, run executeCollateralReturnPlan({ plan }), wait for confirmation, and request a new plan while truncated is true. It needs a Relayer API key and a Deposit, Safe or Proxy wallet.

How do Polymarket Combos settle?

A YES Combo pays the product of its legs' outcomes. If every leg resolves to 1, a share redeems for 1 pUSD. If one leg resolves 50-50 and the rest resolve to 1, it redeems for 0.5, and the NO share redeems for the complement, 1 minus the YES value. When some legs resolve early, the position can be compressed into a simpler one that keeps only the open legs. Redeem winners with redeemPositions({ positionId }), or approve the AutoRedeemer contract for automatic redemption.

What contracts do Polymarket Combos use?

The market maker guide also lists a Router at 0x12121212006e4CD160D18e3f00711DA5c3372600 for splits and position management. Every address above returned deployed code from a Polygon node in our checks on 3 October 2026. Implementation addresses and the rest of Polymarket's contracts are in Polymarket contract addresses.

What are the limits on Polymarket Combos?

Kalshi runs its own version, which its API calls multivariate events, and its RFQ system covers those combo markets with an accept-then-confirm flow. The details are in Kalshi combos and the Kalshi RFQ API guide.

Frequently Asked Questions