# Polymarket Arbitrage Finder — Groups Priced Under $1 (`jpmarketdata/polymarket-odds-arbitrage`) Actor

Type a topic and get Polymarket events priced as a group: buy one share of every outcome, or sell one of each. Returns cost to buy all, money back from selling all, profit % either way, liquidity, for up to 15 events per topic. $0.02 per topic; topics with no priceable group are free. Unofficial.

- **URL**: https://apify.com/jpmarketdata/polymarket-odds-arbitrage.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Automation, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 topic scanned for arbitrages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Polymarket Arbitrage Finder — Groups Priced Under $1

**What it does:** Finds Polymarket events that are a group of Yes/No markets that can't all happen, and prices the whole group: buy every outcome, or sell every outcome.

**You enter:** One or more topics, e.g. `fed rate` or `election`.

**You get:** One row per group: cost to buy one share of every outcome, money back from selling one of each, profit % for buy-all and sell-all, whether every outcome takes orders, liquidity, price change. 15 events per topic by default; overlapping groups get no profit %.

**Price:** $0.02 per topic. +$0.002 per market if you also want each market (off by default). A topic with no priceable group is never charged.

> Unofficial — not affiliated with Polymarket. Reads public pages only.

### What you get

For each topic you enter, the tool takes up to 15 Polymarket events (you can raise this to 50) and prices each one as a group — buying one share of every outcome, or selling one of each.

**One summary row per topic**, with how many events were found, how many groups could be priced, how many had a positive return, the spread of those returns, and the best one found.

**One row per priced group:**

| field | meaning |
|---|---|
| `eventTitle` / `url` / `endDate` | the event, its link, and when it closes |
| `marketCount` / `marketsDropped` | how many outcomes were priced, and how many were left out because they are closed or paused |
| `sumBestAsk` | cost of buying one share of **every** outcome |
| `buyAllEdgePct` | `(1 - sumBestAsk) x 100` — locked-in return if positive |
| `sumBestBid` | proceeds from selling one share of every outcome |
| `sellAllEdgePct` | `(sumBestBid - 1) x 100` |
| `exhaustive` / `tradable` | whether the outcomes really are one full group, and whether every one of them currently accepts orders |
| `edgeUnavailableReason` | plain-English reason when no return figure is given |
| `spreadStats` | how wide the gap between bid and ask is across the group — lowest, middle 50% range, highest |
| `liquidityUsd` / `volume24hrUsd` | money resting in the order books, and 24h traded volume |
| `momentum1wPct` / `momentum1mPct` | typical outcome price change over a week and a month |

Groups smaller than 3 outcomes are skipped by default (a plain Yes/No pair always adds up to $1, so it can never show a gap). Turning on "include individual markets" also returns every market inside the reported groups, one row each.

### The trap this Actor refuses to fall into

A return is only real when exactly one of the outcomes can happen and one of them must — Polymarket marks such a group `negRisk` (its own term for it). Sets of related-but-overlapping questions ("Fed rate cut by March?", "...by June?") add up to far below $1 and look like a 75% profit. They are not.

**Overlapping sets are returned with `exhaustive: false` and no return figure at all**, plus a one-line reason. Nothing in the output invites you to trade a number that does not exist. The same applies when some outcomes of an event are closed or paused: what is left is not the whole group, so it gets no figure either.

### What one row looks like

Measured on 2026-08-09 (real run) — the summary row for the topic `fed rate`, a few fields left out for length

```json
{
  "type": "arbitrage_summary",
  "topic": "fed rate",
  "eventsFound": 26,
  "basketsEvaluated": 4,
  "basketsPriced": 3,
  "basketsNotExhaustive": 1,
  "positiveEdgeBaskets": 1,
  "tradablePositiveEdgeBaskets": 1,
  "bestBuyAllEdge": {
    "eventTitle": "How many Fed rate hikes in 2026?",
    "buyAllEdgePct": 2.1,
    "sumBestAsk": 0.979,
    "marketCount": 6,
    "tradable": true,
    "url": "https://polymarket.com/event/how-many-fed-rate-hikes-in-2026-20260623190717369"
  },
  "totalLiquidityUsd": 4181449.23,
  "checkedAt": "2026-08-09T18:43:26.878092+00:00"
}
```

### Price

**$0.02 per topic scanned** — each topic you enter is charged separately, so three topics in one run cost $0.06. Individual markets are $0.002 each and off by default. **A topic where nothing could be priced is never charged.** You pay per topic; there is no monthly fee.

### Input

```json
{
  "topics": ["fed rate", "election"],
  "minMarketsPerBasket": 3,
  "minEdgePct": 0
}
```

`minEdgePct` decides what is returned, not what is counted: the summary row still counts every group that was priced. Set it to 0 to see them all.

Reads Polymarket's public data only, no login, requests spaced out. Nothing is kept between runs — every run re-reads the live prices.

### If something goes wrong

- **Wrong number or a failed run?** Open a ticket on the **Issues** tab. I read every one and reply within 2 business days (Japan time).
- **You never get a fake "empty" result.** If the site can't be read, the run fails and says so.
- **A topic with nothing priceable = no charge.** A topic that does get a price costs $0.02 even when the profit comes out negative — that number is the result you asked for.
- **Checked every week.** An automatic test runs this tool weekly; if the site changes, I fix it.
- **Public pages only.** No login, no personal data, and it goes easy on the site.

### More tools by the same author

- [Polymarket Odds, Volume & Top Markets by Topic](https://apify.com/jpmarketdata/polymarket-market-stats)
- [Polymarket Markets — Odds, Bid/Ask, Volume, One Row Each](https://apify.com/jpmarketdata/polymarket-markets)
- [Kalshi Arbitrage Finder — Groups Priced Against $1](https://apify.com/jpmarketdata/kalshi-odds-arbitrage)
- [Polymarket vs Kalshi Arbitrage — Same Question, Two Prices](https://apify.com/jpmarketdata/prediction-market-arbitrage)

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): <https://apify.com/jpmarketdata>

### Disclaimer

Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by Polymarket**. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.

# Actor input Schema

## `topics` (type: `array`):

Search terms. Each one is scanned for neg-risk baskets, e.g. "fed rate", "election", "super bowl".

## `activeOnly` (type: `boolean`):

Skip closed and inactive markets. An arbitrage edge on a closed market is not tradable.

## `maxEventsPerTopic` (type: `integer`):

How many events to price per topic.

## `minMarketsPerBasket` (type: `integer`):

Ignore baskets smaller than this. A two-market Yes/No pair is normalised to 1.0 by construction and carries no basket edge.

## `minEdgePct` (type: `integer`):

Only report baskets whose buy-all or sell-all edge is at least this. 0 reports every priced basket.

## `includeIndividualMarkets` (type: `boolean`):

Also return every market inside the reported baskets (charged per market).

## Actor input object example

```json
{
  "topics": [
    "fed rate"
  ],
  "activeOnly": true,
  "maxEventsPerTopic": 15,
  "minMarketsPerBasket": 3,
  "minEdgePct": 0,
  "includeIndividualMarkets": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "topics": [
        "fed rate"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/polymarket-odds-arbitrage").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "topics": ["fed rate"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/polymarket-odds-arbitrage").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "topics": [
    "fed rate"
  ]
}' |
apify call jpmarketdata/polymarket-odds-arbitrage --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/polymarket-odds-arbitrage"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5AinRwnXmd0vGcQVA/builds/y8TXl2COMkDWayfG0/openapi.json