# Alphapoly (polymarket-alpha-bot)

Self-hosted scanner for covering portfolios across correlated Polymarket contracts.

*https://predictionmarkets.tools/tools/polymarket-alpha-bot · Trading Clients, SDKs & Bots*

## Facts

### At a glance

| Field | Value |
| --- | --- |
| Vendor | Chainstack |
| Category | Trading Clients, SDKs & Bots |
| Job | arbitrage |
| Website | https://github.com/chainstacklabs/polymarket-alpha-bot |
| Pricing model | open-source |
| Free tier | true |
| Open source | true |
| Licence | Apache-2.0 |
| Self-hosted | true |
| Tested hands-on | false |
| Last updated | 2026-09-21 |

### Availability

| Field | Value |
| --- | --- |
| Jurisdictions | global |
| Open to US persons | true |
| KYC required | false |

### Markets

| Field | Value |
| --- | --- |
| Subjects | politics, sports, macro, crypto, business |
| Settlement | crypto |
| Resolved by | none |

### Economics

| Field | Value |
| --- | --- |
| Taker fee | none |
| Maker fee | none |
| Liquidity model | clob |
| Platforms | web |
| AI features | research |

### Interfaces

| Field | Value |
| --- | --- |
| API | true |
| WebSocket | false |
| Scripting | none |
| Python | true |
| MCP server | false |
| Export | json |

### Capabilities

Yes: screening, automation, live_trading, portfolio_tracking

No: charting, order_book, backtesting, paper_trading, calibration_scoring, cross_venue, alerts, news, tax_reporting

*Verified: pricing 2026-09-19; availability 2026-09-19; capabilities 2026-09-19.*

## What it is

A self-hosted application, not a library and not a service: a FastAPI backend, a web front end you
run on localhost, and a pipeline that looks for **covering portfolios** across correlated
Polymarket contracts - sets of positions that pay out together whatever happens, bought for less
than they must be worth. Chainstack Labs publishes it under Apache-2.0 as `polymarket-alpha-bot`,
and the README calls the product Alphapoly.

The pipeline is five stages and the repository is candid about which of them a model runs:

1. **Groups** - fetch markets from Polymarket and group them by event.
2. **Implications** - an LLM extracts logical relationships between groups.
3. **Validation** - a second LLM pass validates each implication at the individual market level.
4. **Portfolios** - compute cost and expected profit for validated pairs against live prices.
5. **Positions** - track what you bought and what it is worth.

Trading runs through a per-user deposit wallet - Polymarket signature type 3 - which the app
deploys gaslessly using a Relayer API key from your Polymarket account settings, with the relayer
paying gas. You fund the deposit wallet with pUSD. The README notes that bare externally-owned
accounts cannot trade directly on the V2 order book because of an allowlist, which is the sort of
detail that costs an afternoon to discover on your own.

It is also built to be driven by an agent. `.claude/skills/` holds six skills - run the pipeline,
fetch portfolio opportunities, enter a position, exit a position, add a feature, scaffold an
experiment - and `AGENTS.md` is a symlink to the same instructions for other agent runners.

## Availability

The software installs anywhere: Python through `uv`, Node 18 or newer, and everything runs on
your own machine.

The venue does not. Polymarket's on-chain exchange does not serve US persons - see
[polymarket](https://predictionmarkets.tools/tools/polymarket) - and this app trades there and nowhere else. The flag on this
card describes the software, which nothing stops a US reader installing and reading; what stops
them is the account at the other end, and that fact lives on the venue's card. A US reader who
wants this shape of strategy needs a different venue, and there is no equivalent for
[polymarket-us](https://predictionmarkets.tools/tools/polymarket-us) here.

Note also what leaves your machine while it runs: market text and prompts go to OpenRouter,
whichever model you point it at, and JSON-RPC calls go to your Polygon node provider.

## Pricing

The code is free and Apache-2.0 licensed. Running it is not: the pipeline makes two LLM passes
over grouped markets, and you pay OpenRouter for those tokens, plus whatever your Polygon RPC
provider charges. Chainstack, which publishes the repository, sells exactly that kind of node
access and the README points at its free tier - worth knowing when reading the recommendation.

Trading fees are Polymarket's, and the gas for deploying the deposit wallet is paid by
Polymarket's relayer rather than by you.

## Markets & resolution

The app resolves nothing; Polymarket does, through the UMA optimistic oracle, and that is the
mechanism the whole strategy depends on. A covering portfolio only pays if both legs resolve the
way their logical relationship says they must - so an oracle dispute, an ambiguous question or a
market resolved on a technicality is not an edge case here, it is the failure mode.

The markets it looks at are whatever Polymarket lists, which in practice means politics, sports,
macro, crypto and business questions. It works on the V2 stack with pUSD collateral; the V1
USDC.e path was retired on 2026-04-28 and survives only as the `v1-final` tag.

## Integrations

Python backend, Node front end, Polymarket's own
[polymarket-client](https://predictionmarkets.tools/tools/polymarket-client) SDK in the verification scripts, OpenRouter for
models, and a Polygon RPC endpoint. The backend exposes its own HTTP API with generated
documentation at `/docs`.

There is no MCP server, no exchange abstraction and no second venue.

## Limitations

**An LLM decides what implies what.** Two of the five pipeline stages are model calls, and the
arithmetic downstream is only as good as they are. A hallucinated implication produces a pair that
looks covered and is not, which is a position with real money in it and no hedge behind it. The
repository is explicit that this is what the model does, which is why this card carries
`ai_features: research` rather than anything stronger - it analyses relationships, it does not
forecast outcomes or tell you which side will win.

**It went quiet in July.** Last commit on `main` 2026-07-28, no release since the `v1-final` tag
of 2026-04-27, 181 stars. Not archived, and the V2 migration it documents is recent - but a
strategy app against a moving on-chain venue needs someone at the other end.

**It wants four credentials and one of them is a signing key.** The wallet holds funds and the key
that signs orders is the key that can move them. The README carries no guidance on handling it -
its only safety language is a closing disclaimer that the software is for education and research,
is not financial advice, and that you may lose money. Re-read on 21 September 2026.

**No backtest and no paper mode.** There is no simulator: the pipeline prices live markets and the
positions you take are real.

**Published by an infrastructure vendor.** Chainstack sells Polygon nodes, and this is a good
piece of developer marketing for them as well as a working app. Nothing about it is hidden, but
the default node recommendation is not neutral.

**Nothing here has been run by us** - not the pipeline, not a deposit wallet, not a fill.

## Alternatives

Chainstack publishes a second, smaller thing in the same territory: `polyclaw`, an OpenClaw skill
that browses Polymarket, executes trades and scans for hedges from a chat interface. It is
Apache-2.0 as well and was last committed to in April 2026. It is not carded here.

For a terminal you do not have to run yourself, [polyrama](https://predictionmarkets.tools/tools/polyrama) covers Polymarket and
Kalshi with strategies and backtests.

For building your own instead of running this one, the venue SDKs are
[polymarket-client](https://predictionmarkets.tools/tools/polymarket-client) for Polymarket, with
[ccxt](https://predictionmarkets.tools/tools/ccxt) and [pmxt](https://predictionmarkets.tools/tools/pmxt) if the strategy needs more than one venue.

## FAQ

### Does it trade on its own?

Not on a schedule you have not set. The pipeline finds candidate covered pairs and prices them; entering a position is a step you take in its dashboard, and the repository ships skills that let an agent drive the same steps if you connect one.

### What does the language model actually decide?

Which markets logically imply which. The pipeline groups related markets, then uses an LLM to extract implications between groups and a second pass to validate them market by market; the profit arithmetic on top is deterministic. A wrong implication is a pair that is not actually covered, so the LLM is where the risk sits.

### What credentials does it want?

Four, all yours - an OpenRouter key for the language model, a Polygon RPC endpoint, an EOA signing key and a Polymarket Relayer API key minted in your account settings. It runs on your machine, so nothing is handed to a third party except the LLM prompts and the RPC calls.

### Is it still maintained?

It shipped through the summer and then went quiet. The last commit on the main branch is dated 2026-07-28, the repository is not archived, and its only tagged release, v1-final on 2026-04-27, marks the last commit before Polymarket's V1 collateral stack was retired.

## Background

- [What running a bot does not solve](https://predictionmarkets.tools/guides/what-a-bot-cannot-fix.md) — A bot fixes speed and consistency. Rate limits, a missing rehearsal, a field that stops arriving, a partial fill and a paused market are not coding problems.

- [Where your key lives when software trades for you](https://predictionmarkets.tools/guides/where-your-key-lives.md) — Four different credentials are all called a key, and they differ in what a copy permits. What the clients in this catalogue ask for, and what to ask them back.

## Also worth comparing

- [Polycool](https://predictionmarkets.tools/tools/polycool.md) — Phone-sized Polymarket client with copy trading, parlays and a fee of its own.
- [Polyrama](https://predictionmarkets.tools/tools/polyrama.md) — Polymarket and Kalshi in one terminal, with wallet analytics and a REST API.
- [Synthesis](https://predictionmarkets.tools/tools/synthesis.md) — Polymarket and Kalshi in one browser desk, with copytrading and a shared portfolio.
- [CCXT](https://predictionmarkets.tools/tools/ccxt.md) — One client for seven prediction venues, inside a 104-exchange crypto library.
- [limitless-sdk](https://predictionmarkets.tools/tools/limitless-sdk.md) — Limitless Exchange's own async Python SDK - CLOB and NegRisk orders, WebSocket, MIT.
- [PMXT](https://predictionmarkets.tools/tools/pmxt.md) — CCXT-shaped client for prediction markets, with a hosted API and a self-hosted mode.
