{"id":40,"date":"2026-08-17T21:39:01","date_gmt":"2026-08-17T21:39:01","guid":{"rendered":"https:\/\/polytrade.market\/blog\/how-to-build-polymarket-trading-bot\/"},"modified":"2026-08-17T21:39:01","modified_gmt":"2026-08-17T21:39:01","slug":"how-to-build-polymarket-trading-bot","status":"publish","type":"post","link":"https:\/\/polytrade.market\/blog\/how-to-build-polymarket-trading-bot\/","title":{"rendered":"How to Build a Polymarket Trading Bot in 2026: API, Strategy &#038; Risk Controls"},"content":{"rendered":"<style>.affiliate-callout .button,.article-cta .button{display:inline-block!important;background:#2E5CFF!important;color:#FFFFFF!important;border:1px solid #2E5CFF!important;border-radius:10px!important;padding:14px 22px!important;font-weight:700!important;text-decoration:none!important;line-height:1.2!important}.affiliate-callout .button:hover,.article-cta .button:hover{background:#244BD6!important;border-color:#244BD6!important;color:#FFFFFF!important}article table{width:100%!important;border-collapse:separate!important;border-spacing:0!important;margin:28px 0 36px!important;border:1px solid #334155!important;border-radius:12px!important;overflow:hidden!important;background:#0F1725!important}article table th,article table td{padding:14px 16px!important;text-align:left!important;vertical-align:top!important;border-right:1px solid #334155!important;border-bottom:1px solid #334155!important;line-height:1.45!important}article table th:last-child,article table td:last-child{border-right:0!important}article table tbody tr:last-child td{border-bottom:0!important}article table thead th{background:#172554!important;color:#FFFFFF!important;font-weight:700!important}article table tbody td{background:#0F1725!important;color:#E5E7EB!important}article table tbody tr:nth-child(even) td{background:#111C2D!important}article pre{background:#08111f!important;border:1px solid #26364d!important;border-radius:12px!important;padding:18px!important;overflow-x:auto!important;color:#d7e3f4!important;line-height:1.55!important}@media(max-width:700px){article table{display:block!important;overflow-x:auto!important;white-space:nowrap!important}article table th,article table td{min-width:180px!important}}<\/style>\n<figure class=\"wp-block-image size-full article-cover\"><img decoding=\"async\" src=\"https:\/\/polytrade.market\/blog\/wp-content\/uploads\/2026\/08\/how-to-build-polymarket-trading-bot-cover.jpg\" alt=\"How to build a Polymarket trading bot cover image\"\/><figcaption>A production-ready Polymarket trading bot needs market data, execution logic, risk controls, and monitoring.<\/figcaption><\/figure>\n<p class=\"article-lead\">Building a Polymarket trading bot is not mainly an order-submission problem. The difficult part is keeping market data current, measuring an edge against executable prices, preventing duplicate or oversized orders, and reconciling every fill.<\/p>\n<p>This guide walks through a practical architecture for a Polymarket trading bot in 2026. It covers market discovery, real-time order books, strategy logic, order execution, risk controls, paper testing, and production monitoring. It does not promise profit. A bot automates a process; it cannot create an edge that is not there.<\/p>\n<figure class=\"wp-block-image size-full\"><img decoding=\"async\" src=\"https:\/\/polytrade.market\/blog\/wp-content\/uploads\/2026\/08\/build-polymarket-trading-bot-developer.jpg\" alt=\"Developer building a Polymarket trading bot at a realistic workstation\"\/><figcaption>Start with a small, observable system before adding strategy complexity or live capital.<\/figcaption><\/figure>\n<section>\n<h2>What a Polymarket trading bot actually does<\/h2>\n<p>A complete bot repeats a controlled loop:<\/p>\n<ol>\n<li>discover a market and its outcome token IDs;<\/li>\n<li>subscribe to fresh bids, asks, trades, and market-state updates;<\/li>\n<li>calculate a strategy signal;<\/li>\n<li>check price, liquidity, exposure, balance, and system health;<\/li>\n<li>create and submit an order;<\/li>\n<li>track the order through fill and settlement states;<\/li>\n<li>reconcile the resulting position;<\/li>\n<li>record every decision for later review.<\/li>\n<\/ol>\n<p>The official <a href=\"https:\/\/docs.polymarket.com\/trading\/quickstart\" target=\"_blank\" rel=\"noopener noreferrer\">Polymarket trading quickstart<\/a> shows the core authenticated order flow. A production bot adds several layers around that flow so one stale signal or unexpected partial fill does not become an uncontrolled position.<\/p>\n<\/section>\n<section>\n<h2>The seven components of a production bot<\/h2>\n<table>\n<thead>\n<tr>\n<th>Component<\/th>\n<th>Job<\/th>\n<th>Failure to prevent<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Market discovery<\/td>\n<td>Finds events, markets, outcomes, and token IDs<\/td>\n<td>Trading the wrong outcome or closed market<\/td>\n<\/tr>\n<tr>\n<td>Market-data service<\/td>\n<td>Maintains live bids, asks, trades, and timestamps<\/td>\n<td>Acting on stale prices<\/td>\n<\/tr>\n<tr>\n<td>Strategy engine<\/td>\n<td>Turns data into a priced signal<\/td>\n<td>Trading without a measurable edge<\/td>\n<\/tr>\n<tr>\n<td>Risk engine<\/td>\n<td>Applies size, exposure, loss, and latency limits<\/td>\n<td>Oversized or concentrated positions<\/td>\n<\/tr>\n<tr>\n<td>Execution engine<\/td>\n<td>Creates, submits, updates, and cancels orders<\/td>\n<td>Duplicate and uncontrolled orders<\/td>\n<\/tr>\n<tr>\n<td>Reconciliation<\/td>\n<td>Compares expected orders with actual balances<\/td>\n<td>Hidden position drift<\/td>\n<\/tr>\n<tr>\n<td>Monitoring<\/td>\n<td>Alerts on data, order, balance, and service failures<\/td>\n<td>Silent production errors<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/section>\n<aside class=\"affiliate-callout\"><strong>Explore current Polymarket markets<\/strong><span>Study live spreads, order-book depth, and resolution rules before designing a strategy.<\/span><a class=\"button\" href=\"https:\/\/polymarket.com\/?r=nonamesx\" target=\"_blank\" rel=\"sponsored noopener noreferrer\">Register on Polymarket \u2197<\/a><\/aside>\n<section>\n<h2>Step 1: define the strategy before writing the bot<\/h2>\n<p>A strategy needs a falsifiable rule. Fast code without a priced hypothesis only loses money faster. Write down the signal, entry condition, exit condition, expected holding time, required liquidity, and maximum acceptable loss.<\/p>\n<p>Common strategy families include:<\/p>\n<ul>\n<li><strong>Market making:<\/strong> quote both sides and attempt to earn spread while controlling inventory.<\/li>\n<li><strong>Arbitrage:<\/strong> trade logically inconsistent executable prices across outcomes or related markets.<\/li>\n<li><strong>Information reaction:<\/strong> update fair probability when a trusted source releases new evidence.<\/li>\n<li><strong>Wallet tracking:<\/strong> treat selected public wallet trades as signals under independent follower limits.<\/li>\n<li><strong>Relative value:<\/strong> compare related probability curves and trade the difference.<\/li>\n<\/ul>\n<p>Our guide to <a href=\"https:\/\/polytrade.market\/blog\/how-do-polymarket-bots-make-money\/\">how Polymarket bots make money<\/a> explains the risks behind each approach. Choose one narrow strategy for the first version. Mixing several unfinished ideas makes debugging almost impossible.<\/p>\n<\/section>\n<section>\n<h2>Step 2: discover markets and outcome token IDs<\/h2>\n<p>A bot should not hardcode a market title and assume it never changes. Store stable identifiers, market status, outcomes, token IDs, resolution details, minimum order size, tick size, fee parameters, and whether order-book trading is enabled.<\/p>\n<p>Before every new order, verify that the market is active, the intended outcome token is correct, and the strategy still applies to the exact resolution language.<\/p>\n<pre><code>market = discover_by_slug(target_slug)\nassert market.active\nassert market.order_book_enabled\noutcome = select_outcome(market, desired_side)\ntoken_id = outcome.token_id<\/code><\/pre>\n<p>This pseudocode is intentionally simple. The important design choice is validation before execution, not the programming language.<\/p>\n<\/section>\n<section>\n<h2>Step 3: maintain a real-time order book<\/h2>\n<p>Displayed market prices are not enough for execution. A buyer pays available asks and a seller receives available bids. Your bot needs the price and quantity available for its intended size.<\/p>\n<p>The official <a href=\"https:\/\/docs.polymarket.com\/market-data\/realtime-data\" target=\"_blank\" rel=\"noopener noreferrer\">real-time market-data documentation<\/a> describes streams for order-book changes, price changes, last-trade prices, and market lifecycle updates. Use timestamps on every update and reject stale data.<\/p>\n<p>For each token, maintain:<\/p>\n<ul>\n<li>best bid and best ask;<\/li>\n<li>full depth or enough levels for your maximum size;<\/li>\n<li>spread;<\/li>\n<li>last trade price and time;<\/li>\n<li>market status;<\/li>\n<li>last successful stream timestamp;<\/li>\n<li>sequence or snapshot consistency where available.<\/li>\n<\/ul>\n<p>If the stream disconnects or falls behind, the bot should stop new orders until it rebuilds a valid state.<\/p>\n<\/section>\n<section>\n<h2>Step 4: calculate executable price, not screen price<\/h2>\n<p>Suppose the best ask is $0.42 for 100 shares, the next level is $0.44 for 200, and the next is $0.47 for 500. A 500-share buy cannot be modeled at $0.42. The expected average is based on all consumed levels.<\/p>\n<p>Use depth-weighted price:<\/p>\n<p><strong>Average execution price = total cost across consumed levels \u00f7 filled shares<\/strong><\/p>\n<table>\n<thead>\n<tr>\n<th>Ask level<\/th>\n<th>Available shares<\/th>\n<th>Shares consumed<\/th>\n<th>Cost<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>$0.42<\/td>\n<td>100<\/td>\n<td>100<\/td>\n<td>$42<\/td>\n<\/tr>\n<tr>\n<td>$0.44<\/td>\n<td>200<\/td>\n<td>200<\/td>\n<td>$88<\/td>\n<\/tr>\n<tr>\n<td>$0.47<\/td>\n<td>500<\/td>\n<td>200<\/td>\n<td>$94<\/td>\n<\/tr>\n<tr>\n<td><strong>Total<\/strong><\/td>\n<td><\/td>\n<td><strong>500<\/strong><\/td>\n<td><strong>$224<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The modeled average is $0.448 before other costs. A signal based on $0.42 would overstate its edge.<\/p>\n<\/section>\n<section>\n<h2>Step 5: build the strategy engine<\/h2>\n<p>The strategy engine should output more than buy or sell. It should produce a structured proposal that can be audited:<\/p>\n<pre><code>proposal = {\n  market_id,\n  token_id,\n  side,\n  model_price,\n  maximum_order_price,\n  requested_size,\n  expected_edge,\n  signal_timestamp,\n  strategy_version,\n  reason\n}<\/code><\/pre>\n<p>The risk engine can then accept, resize, or reject the proposal. Keeping signal generation separate from execution prevents strategy code from bypassing portfolio limits.<\/p>\n<\/section>\n<figure class=\"wp-block-image size-full\"><img decoding=\"async\" src=\"https:\/\/polytrade.market\/blog\/wp-content\/uploads\/2026\/08\/polymarket-bot-operations-risk-monitoring.jpg\" alt=\"Polymarket bot operations desk with risk and order monitoring\"\/><figcaption>Live automation needs monitoring for data freshness, order state, exposure, and reconciliation.<\/figcaption><\/figure>\n<section>\n<h2>Step 6: put risk controls in a separate gate<\/h2>\n<p>Every proposed order should pass the same controls regardless of strategy:<\/p>\n<table>\n<thead>\n<tr>\n<th>Control<\/th>\n<th>Example question<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Data freshness<\/td>\n<td>Is the order book newer than the maximum allowed age?<\/td>\n<\/tr>\n<tr>\n<td>Price bound<\/td>\n<td>Can the order fill without crossing the worst acceptable price?<\/td>\n<\/tr>\n<tr>\n<td>Liquidity<\/td>\n<td>Is enough depth available for the requested size?<\/td>\n<\/tr>\n<tr>\n<td>Market exposure<\/td>\n<td>Would the new position exceed the market cap?<\/td>\n<\/tr>\n<tr>\n<td>Category exposure<\/td>\n<td>Is the portfolio already concentrated in this topic?<\/td>\n<\/tr>\n<tr>\n<td>Daily loss<\/td>\n<td>Has the strategy or account hit its stop?<\/td>\n<\/tr>\n<tr>\n<td>Balance<\/td>\n<td>Is sufficient spendable balance available after open orders?<\/td>\n<\/tr>\n<tr>\n<td>Duplicate protection<\/td>\n<td>Has an equivalent signal already created an order?<\/td>\n<\/tr>\n<tr>\n<td>System health<\/td>\n<td>Are data, execution, database, and alerts healthy?<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Risk controls should fail closed. When status is uncertain, reject new activity and alert an operator.<\/p>\n<\/section>\n<aside class=\"affiliate-callout\"><strong>Start with paper execution<\/strong><span>Test the full signal, risk, and order-state workflow before using live capital.<\/span><a class=\"button\" href=\"https:\/\/polymarket.com\/?r=nonamesx\" target=\"_blank\" rel=\"sponsored noopener noreferrer\">Open Polymarket \u2197<\/a><\/aside>\n<section>\n<h2>Step 7: choose order behavior deliberately<\/h2>\n<p>Order behavior changes strategy results. An immediate order may fill quickly but pay spread and slippage. A resting limit order controls price but may never execute.<\/p>\n<p>The official <a href=\"https:\/\/docs.polymarket.com\/concepts\/order-lifecycle\" target=\"_blank\" rel=\"noopener noreferrer\">order lifecycle guide<\/a> describes Good Till Cancelled, Good Till Date, Fill Or Kill, Fill And Kill, and post-only behavior.<\/p>\n<table>\n<thead>\n<tr>\n<th>Order behavior<\/th>\n<th>Useful when<\/th>\n<th>Main trade-off<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>GTC<\/td>\n<td>You can wait for a limit price<\/td>\n<td>Open order can become stale<\/td>\n<\/tr>\n<tr>\n<td>GTD<\/td>\n<td>The signal has a clear expiration<\/td>\n<td>May expire without filling<\/td>\n<\/tr>\n<tr>\n<td>FOK<\/td>\n<td>Partial size would break the strategy<\/td>\n<td>Entire order may be canceled<\/td>\n<\/tr>\n<tr>\n<td>FAK<\/td>\n<td>Partial execution is acceptable<\/td>\n<td>Position may be smaller than planned<\/td>\n<\/tr>\n<tr>\n<td>Post only<\/td>\n<td>You want to add liquidity<\/td>\n<td>Rejected if it would immediately match<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/section>\n<section>\n<h2>Step 8: treat order submission as a state machine<\/h2>\n<p>Submitting an order is not the end. Store a client-generated idempotency key before sending it, then track every response and transition.<\/p>\n<pre><code>signal_created\nrisk_approved\norder_submitting\norder_live | order_matched | order_partial | order_rejected\ntrade_confirming\nposition_reconciled\nclosed<\/code><\/pre>\n<p>Retries must reuse the same intent rather than create a new order. After any timeout, query the authoritative order state before deciding to submit again.<\/p>\n<\/section>\n<section>\n<h2>Step 9: reconcile positions and balances<\/h2>\n<p>Your database is an expectation, not the final truth. Periodically compare open orders, filled amounts, positions, and spendable balance with authoritative account data.<\/p>\n<p>Reconciliation should detect:<\/p>\n<ul>\n<li>an order marked live locally but already filled;<\/li>\n<li>a partial fill recorded as complete;<\/li>\n<li>a duplicate order;<\/li>\n<li>a position without a known originating order;<\/li>\n<li>balance reserved by forgotten open orders;<\/li>\n<li>a settlement or redemption not reflected locally.<\/li>\n<\/ul>\n<p>Pause trading when unexplained differences exceed a small threshold.<\/p>\n<\/section>\n<section>\n<h2>Step 10: secure signing and credentials<\/h2>\n<p>Never place raw private keys in source code, logs, chat messages, or analytics tools. Use a dedicated signing boundary, least-privilege access, encrypted secret storage, and separate development and production identities.<\/p>\n<p>Log intent, order IDs, prices, sizes, timestamps, and results\u2014but never credentials or sensitive signing material. Add manual revocation and a kill switch before live deployment.<\/p>\n<\/section>\n<section>\n<h2>Step 11: paper-test the complete system<\/h2>\n<p>A strategy backtest is not enough. Paper mode should run the same market-data, signal, risk, state-machine, and reconciliation code as production while replacing live submission with simulated depth-aware fills.<\/p>\n<p>Test:<\/p>\n<ul>\n<li>normal fills;<\/li>\n<li>partial fills;<\/li>\n<li>empty and rapidly moving books;<\/li>\n<li>stale market data;<\/li>\n<li>stream disconnections;<\/li>\n<li>duplicate signals;<\/li>\n<li>submission timeouts;<\/li>\n<li>delayed confirmations;<\/li>\n<li>daily loss stops;<\/li>\n<li>manual kill-switch activation.<\/li>\n<\/ul>\n<p>Our <a href=\"https:\/\/polytrade.market\/blog\/why-copy-traders-should-start-with-paper-mode\/\">paper trading guide<\/a> explains why realistic depth and skipped trades matter.<\/p>\n<\/section>\n<section>\n<h2>Step 12: monitor what can lose money<\/h2>\n<p>Production monitoring should focus on financial and operational risk, not just CPU and memory.<\/p>\n<table>\n<thead>\n<tr>\n<th>Alert<\/th>\n<th>Why it matters<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Market data too old<\/td>\n<td>Orders may use stale prices<\/td>\n<\/tr>\n<tr>\n<td>Spread or depth changed sharply<\/td>\n<td>Expected execution may no longer be valid<\/td>\n<\/tr>\n<tr>\n<td>Order state unknown<\/td>\n<td>A retry could create a duplicate position<\/td>\n<\/tr>\n<tr>\n<td>Position mismatch<\/td>\n<td>Local exposure is unreliable<\/td>\n<\/tr>\n<tr>\n<td>Daily drawdown reached<\/td>\n<td>New orders must stop<\/td>\n<\/tr>\n<tr>\n<td>Repeated rejection or failure<\/td>\n<td>Credentials, balance, market, or logic may be wrong<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/section>\n<section>\n<h2>Common mistakes when building a Polymarket bot<\/h2>\n<ol>\n<li><strong>Using the displayed midpoint as an execution price.<\/strong> Read bids, asks, and depth.<\/li>\n<li><strong>Mixing strategy and execution code.<\/strong> A signal should never bypass risk checks.<\/li>\n<li><strong>Assuming submitted means filled.<\/strong> Track order and trade states.<\/li>\n<li><strong>Retrying without idempotency.<\/strong> Timeouts can create duplicates.<\/li>\n<li><strong>Ignoring partial fills.<\/strong> The resulting position can differ from the plan.<\/li>\n<li><strong>Backtesting without latency and slippage.<\/strong> Paper profits may be impossible live.<\/li>\n<li><strong>Skipping reconciliation.<\/strong> Small state errors accumulate into real exposure.<\/li>\n<li><strong>Starting with too much capital.<\/strong> Prove operations before scaling.<\/li>\n<\/ol>\n<\/section>\n<section>\n<h2>A practical minimum viable bot<\/h2>\n<p>The first version should be intentionally boring:<\/p>\n<ul>\n<li>one strategy;<\/li>\n<li>one or a small set of markets;<\/li>\n<li>fixed maximum order size;<\/li>\n<li>strict price and exposure limits;<\/li>\n<li>paper mode by default;<\/li>\n<li>a complete audit log;<\/li>\n<li>manual review before enabling live submission;<\/li>\n<li>automatic shutdown on stale data or unknown order state.<\/li>\n<\/ul>\n<p>Add complexity only after the simple version produces explainable, reproducible results.<\/p>\n<\/section>\n<section>\n<h2>Deployment checklist<\/h2>\n<ul>\n<li>Market and token validation runs before every order.<\/li>\n<li>All data carries freshness timestamps.<\/li>\n<li>Depth-weighted execution is modeled.<\/li>\n<li>Risk checks cannot be bypassed.<\/li>\n<li>Every order has an idempotency key.<\/li>\n<li>Partial fills and cancellations are tested.<\/li>\n<li>Positions and balances reconcile automatically.<\/li>\n<li>Secrets never enter logs.<\/li>\n<li>Alerts reach a human operator.<\/li>\n<li>A manual kill switch is tested.<\/li>\n<li>Paper results include costs, drawdown, and skipped trades.<\/li>\n<\/ul>\n<\/section>\n<section class=\"article-faq\"><span class=\"eyebrow\">QUICK ANSWERS<\/span><\/p>\n<h2>Frequently asked questions<\/h2>\n<details>\n<summary>What language should I use for a Polymarket trading bot?<\/summary>\n<p>Use a language your team can test and operate reliably. TypeScript and Python are common choices, but architecture, risk controls, and observability matter more than language.<\/p>\n<\/details>\n<details>\n<summary>Can a Polymarket bot guarantee profit?<\/summary>\n<p>No. Automation cannot guarantee that a strategy has an edge or that future markets will behave like historical data.<\/p>\n<\/details>\n<details>\n<summary>Should I start with market making or arbitrage?<\/summary>\n<p>Start with the strategy you can measure and test best. Both require realistic order-book depth and strong handling of fills, price movement, and risk.<\/p>\n<\/details>\n<details>\n<summary>Do I need real-time data?<\/summary>\n<p>For live execution, stale data is dangerous. Use real-time updates or a rigorously freshness-checked alternative and stop trading when the data state is uncertain.<\/p>\n<\/details>\n<details>\n<summary>How long should paper testing run?<\/summary>\n<p>Use enough varied activity to cover normal markets, volatility, thin liquidity, partial fills, disconnections, and losing periods. A fixed number of days alone is not sufficient.<\/p>\n<\/details>\n<\/section>\n<div class=\"risk-note\"><strong>Risk disclosure<\/strong><\/p>\n<p>Prediction-market and automated trading involve substantial risk of loss. This guide is educational and does not guarantee profit. Review market rules, platform terms, and eligibility in your jurisdiction.<\/p>\n<\/div>\n<div class=\"article-cta\"><span>Build carefully, test deeply<\/span><\/p>\n<h2>Register on the official Polymarket website.<\/h2>\n<p><a class=\"button\" href=\"https:\/\/polymarket.com\/?r=nonamesx\" target=\"_blank\" rel=\"sponsored noopener noreferrer\">Register on Polymarket \u2197<\/a><\/p>\n<p><small class=\"disclosure\">Affiliate disclosure: Polytrade may receive referral rewards if you register and trade through this link, at no additional cost to you.<\/small><\/div>\n","protected":false},"excerpt":{"rendered":"<p>Build a Polymarket trading bot step by step: market data, real-time feeds, signals, order execution, risk controls, testing, and monitoring.<\/p>\n","protected":false},"author":2,"featured_media":38,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[8,11,10],"class_list":["post-40","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-guides","tag-polymarket-api","tag-polymarket-trading-bot","tag-trading-automation"],"_links":{"self":[{"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/posts\/40","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/comments?post=40"}],"version-history":[{"count":0,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/posts\/40\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/media\/38"}],"wp:attachment":[{"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/media?parent=40"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/categories?post=40"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/polytrade.market\/blog\/wp-json\/wp\/v2\/tags?post=40"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}