Resources
Migrate from Dome / pmxt
A method-by-method mapping for teams moving to Synpath.
Why teams move
- Dome has been acquired by Polymarket. Every Dome API reaches end of life on 28 April 2026, and the SDKs with it.
- pmxt is no longer maintained. Its last release and last commit were on 18 July 2026, and over a thousand issues and pull requests sit open on its tracker.
- Synpath is actively maintained by an open-source community, under the MIT licence, with the same unified shape both projects promised: one client, one schema, one id, across Kalshi, Polymarket and Polymarket US.
Synpath runs in your process and talks to the venues directly. Market data needs no key at all; order entry uses the venue keys you already hold. There is no hosted proxy between you and the exchange to be sunset.
pip uninstall pmxt dome-api-sdk
pip install synpathThe three things that change
- One class, keyed by venue.
pmxt.Polymarket()anddome.polymarket.marketsbecomesynpath.exchange("polymarket"), orsynpath.Client(), which routes on the id. - One id per market. Dome's
token_idandcondition_id, and pmxt'smarketIdplusoutcomeId, become a singlevenue:nativeid. YES and NO are sides of the order, not separate ids. See Synpath IDs. - One price. Every price is the YES price. There is no per-outcome price array to index into;
market.yes.quoteandmarket.no.quoteare both on the market.
From pmxt
Client
| pmxt | Synpath |
|---|---|
pmxt.Polymarket(pmxt_api_key="...") | synpath.exchange("polymarket") |
pmxt.Kalshi(...) | synpath.exchange("kalshi") |
pmxt.Router(...) | synpath.Client(); every venue behind one object |
PMXT_API_KEY | Not needed for market data. Venue keys for trading. |
Market data
| pmxt | Synpath | Note |
|---|---|---|
fetch_markets(query, limit, offset) | fetch_markets(query, limit, cursor) | Cursor paging; read page.next_cursor. |
fetch_events(...) | fetch_events(...) | Markets nested on each event, as before. |
fetch_market(market_id) | fetch_market(market_id) | The id carries the venue. |
fetch_order_book(outcome_id) | fetch_order_book(market_id, side="yes") | One book per market; side selects the view. |
fetch_trades(outcome_id) | fetch_trades(market_id) | Prices in YES terms. |
fetch_ohlcv(outcome_id, timeframe) | fetch_ohlcv(market_id, timeframe) | Read price_source on each candle. |
status="active" | status="open" | open, unopened, closed, settled. |
Fields
| pmxt | Synpath |
|---|---|
market.outcomes[0].price | market.yes.quote.last |
market.outcomes[1].price | market.no.quote.last |
outcome.outcomeId | Gone. Pass side instead. |
market.volume24h | market.volume_24h |
market.marketId | market.id |
Trading
| pmxt | Synpath |
|---|---|
create_order(outcome_id, side="buy", price, amount) | create_order(OrderRequest(market_id, side="buy", price, amount)) |
| Buying the NO outcome | side="sell" |
cancel_order(order_id) | cancel_order(order_id, market_id=...) |
fetch_positions() | fetch_positions() |
fetch_balance() | fetch_balance("polymarket") |
Trading calls are async in Synpath. Market data stays synchronous.
Before (pmxt)
import pmxt
poly = pmxt.Polymarket(pmxt_api_key="pmxt_live_...")
markets = poly.fetch_markets(query="election", limit=3)
for m in markets:
print(m.title, m.outcomes[0].price)After (Synpath)
import synpath
poly = synpath.exchange("polymarket")
markets = poly.fetch_markets(query="election", limit=3)
for m in markets:
print(m.title, m.yes.quote.last)From Dome
Client
| Dome | Synpath |
|---|---|
DomeClient(api_key="...") | synpath.Client() |
dome.polymarket.markets | synpath.exchange("polymarket") |
dome.kalshi.markets | synpath.exchange("kalshi") |
Market data
| Dome | Synpath | Note |
|---|---|---|
get_markets(status, limit, pagination_key) | fetch_markets(status, limit, cursor) | A page, not {markets: [...]}. |
get_market_price(token_id) | fetch_market(market_id).yes.quote | bid, ask and last on one object. |
get_orderbook(token_id) | fetch_order_book(market_id, side) | YES or NO view of one book. |
get_candlesticks(condition_id, start_ts, end_ts) | fetch_ohlcv(market_id, timeframe, since, until) | Unix milliseconds. |
get_trades(...) | fetch_trades(market_id) | |
get_orders(user) | fetch_open_orders() | Your own orders, with your own key. |
get_wallet_pnl(...) | engine.pnl(...) | Your own P&L through the engine; wallet analytics for arbitrary addresses have no equivalent. |
matched markets | Coming, as a hosted service | Cross-venue matching is not in the library. |
Identifiers
| Dome | Synpath |
|---|---|
token_id (a Polymarket outcome token) | polymarket:<gamma id> plus side |
condition_id | polymarket:<gamma id> |
market_slug, event_slug | Search with query, or resolve once with fetch_markets |
ticker (Kalshi) | kalshi:<ticker> |
Before (Dome)
from dome_api_sdk import DomeClient
dome = DomeClient(api_key="your-key")
price = dome.polymarket.markets.get_market_price(token_id="9825044544769936...")
print(price.price)After (Synpath)
import synpath
market = synpath.Client().fetch_market("polymarket:2252244")
print(market.yes.quote.last)Dome ids are Polymarket's own ids, so nothing is lost: a
condition_id still resolves through fetch_markets_by_ids once you prefix the Gamma id with polymarket:, and a token_id maps to that market plus the side it represented.What has no equivalent
- Wallet analytics for other people's addresses (Dome). Synpath reports your own positions, fills and P&L.
- A hosted API key. Neither project's key carries over; there is nothing to replace it with for market data.
- Some of pmxt's long-tail venues (Myriad and others). Synpath covers 10 venues today (Kalshi, Polymarket, Polymarket US, Opinion, Hyperliquid, predict.fun, Limitless, SX Bet, Betfair and Smarkets), with more on the roadmap.
What you gain
- Order entry on every prediction market venue, with stops, icebergs, brackets, TWAP, pegs and smart takers the venues do not hold.
- Live streams for books, trades, orders and fills, with reconnect and resync built in.
- A journaled execution engine that survives a crash without sending an order twice.
- A REST and WebSocket server you can run yourself, with a typed OpenAPI schema for any other language.
Start with the Quickstart, then the REST API reference for every call.

