VPS for Polymarket and Prediction Market Bots: Real Latency from Amsterdam, Rules and Setup

A VPS for Polymarket bots, or for any prediction market bot, is only as fast as a real answer from the market's API, and that is not the "under 1 ms" in hosting ads. Polymarket's documentation names eu-west-2, the AWS region in London, as the home of its primary servers, and every API host sits behind Cloudflare. From our Amsterdam test server on 12 October 2026, a TCP connection to clob.polymarket.com took 1.3 ms, because it only reaches Cloudflare's Amsterdam data centre. A WebSocket round trip to the order book feed took 12.3 ms and a REST request over an open connection 25.8 ms, both medians. One rule matters more than these numbers: a server in another country doesn't change where you are, and Polymarket's terms bar trading by people in the Netherlands, Ireland, the UK, the US and many other places.

Key facts, checked on 12 October 2026:

• Polymarket gives eu-west-2 (AWS London) as the region of its primary servers. Market makers and own-account traders who complete a KYC/KYB form can co-locate in eu-west-2 (Polymarket geoblock docs).
• Polymarket's terms of use, effective 11 August 2026, don't allow trading by people who live in, are located in or are incorporated in 22 named jurisdictions, among them the US, the UK, France, Germany, Ireland and the Netherlands. Using a VPN or a similar tool to get around that is "strictly prohibited".
• Our lab measured a 7.3 ms TCP connect from Amsterdam to AWS London. Opening a new connection for every REST request doubled the response time, to 52 ms.
• Since 4 September 2026, crypto markets have a 150 ms taker delay: an order that would match at once waits that long before it is matched (Polymarket changelog). That is about twenty times the network gap between Amsterdam and London.

The rules, before you rent anything:

• A VPS does not change where you legally are. Polymarket's terms look at where you live, where you are, your citizenship and where your company is registered, not at the server's address.
• Using a server, VPN or proxy in another country to get around a geo-block breaks Polymarket's terms and may break the law where you live. Polymarket can put such a wallet in close-only mode.
• RS Computers does not help anyone bypass geographic restrictions. Our acceptable use policy forbids using our servers to break the law or to run open proxies.
• Polymarket sends US users to Polymarket US, which its site describes as a CFTC-regulated exchange run by a separate company.
• This page is about infrastructure, not financial advice. Polymarket's terms warn that you can lose the full amount you put into a contract.

Polymarket's API in plain words

The API overview lists the hosts a bot uses. clob.polymarket.com is the CLOB, the central limit order book: prices, order books, placing and cancelling orders. gamma-api.polymarket.com lists markets; each outcome of a market, such as Yes or No, is a token with its own ID and order book. wss://ws-subscriptions-clob.polymarket.com/ws/market is a public WebSocket, a connection that stays open and pushes order book changes. The WebSocket docs ask the client to send the text PING every 10 seconds, and the server answers PONG.

Market data needs no account. Trading needs a wallet signature (EIP-712) to create an API key, secret and passphrase, then an HMAC-SHA256 signature on every private request. We tested none of the private side: no orders, no keys, no wallet.

The lab: measuring from Amsterdam

We worked in a Debian 13 container limited to 1 GiB of memory and 2 CPU cores on our 8-core Amsterdam test server, on 12 October 2026 between 09:45 and 10:30 UTC. We ran everything twice, the second time with exactly the commands below; the kept-open, WebSocket and network medians agreed within 2 ms. Requests went out 0.3 to 0.5 seconds apart, far below Polymarket's limits. Other test labs shared the host, so our worst cases include some waiting for CPU.

Step 1: tools and a normal user

# as root
apt update
apt install -y curl bind9-dnsutils mtr-tiny whois jq python3-venv
useradd -m -s /bin/bash bot
su - bot

The install took about 10 seconds. Everything after this runs as bot, a normal user without root rights, so a script that misbehaves can't change the system.

Step 2: find out who answers

# as the bot user
dig +short clob.polymarket.com
whois -h whois.cymru.com " -v 104.18.34.205"
curl -s https://clob.polymarket.com/cdn-cgi/trace | grep -E '^(colo|loc)='
curl -s https://polymarket.com/api/geoblock; echo
echo $(( $(curl -s https://clob.polymarket.com/time) - $(date +%s) ))

dig printed 104.18.34.205 and 172.64.153.51, the same pair as the Gamma, Data and WebSocket hosts. whois named CLOUDFLARENET - Cloudflare, Inc., AS13335: anycast addresses that every Cloudflare data centre answers, and colo=AMS showed Amsterdam took our requests. The last line printed 0, so our clock matched Polymarket's; signed requests carry a timestamp.

The geoblock check, Polymarket's test of the address a request comes from, answered {"blocked":true,...,"country":"NL","region":"NH"} over IPv6 and IPv4 alike. It reads the server's address, not yours. Polymarket's table lists the Netherlands and Ireland as close-only on the website while the API itself is not restricted for them, and we sent no orders to find out more. The terms are clearer: people who live in, are located in or are citizens of these countries may not trade, and a server elsewhere that answers false doesn't change that.

Step 3: time new connections

curl can report how long each phase of a request took. cold.sh opens a new connection per request, like a script started by cron, and pct.py turns the timings into percentiles:

# as the bot user
mkdir -p ~/lab && cd ~/lab
cat > cold.sh <<'EOF'
#!/bin/bash
# cold.sh URL COUNT OUTFILE - one new connection per request, like a script that runs and exits
url="$1"; n="${2:-200}"; out="${3:-cold.txt}"
: > "$out"
for i in $(seq "$n"); do
  curl -4 -s -o /dev/null \
    -w '%{time_namelookup} %{time_connect} %{time_appconnect} %{time_starttransfer} %{http_code}\n' \
    "$url" >> "$out"
  sleep 0.3
done
echo "saved $(wc -l < "$out") samples to $out"
EOF
chmod +x cold.sh
cat > pct.py <<'EOF'
#!/usr/bin/env python3
"""pct.py FILE - p50/p95/p99 in milliseconds from cold.sh output."""
import sys

rows = [line.split() for line in open(sys.argv[1]) if line.strip()]
codes = sorted({r[4] for r in rows})
dns, tcp, tls, wait, ttfb = [], [], [], [], []
for r in rows:
    n, c, a, s = (float(x) * 1000 for x in r[:4])
    dns.append(n); tcp.append(c - n); tls.append(a - c); wait.append(s - a); ttfb.append(s)

def pct(values, p):
    v = sorted(values)
    return v[max(0, int(round(p / 100 * len(v))) - 1)]

print(f"{len(rows)} samples, HTTP codes: {' '.join(codes)}")
print(f"{'step':<22}{'p50':>8}{'p95':>8}{'p99':>8}{'max':>8}")
for name, v in [("DNS lookup", dns), ("TCP connect", tcp), ("TLS handshake", tls),
                ("request to 1st byte", wait), ("total to 1st byte", ttfb)]:
    print(f"{name:<22}{pct(v,50):8.1f}{pct(v,95):8.1f}{pct(v,99):8.1f}{max(v):8.1f}")
EOF

The first line below picks the most liquid open market and keeps the ID of its first outcome token, which in our run was a 77-digit number. Stay in this shell, because later steps reuse $TOKEN:

# as the bot user, in ~/lab
TOKEN=$(curl -s "https://gamma-api.polymarket.com/markets?closed=false&order=liquidity&ascending=false&limit=1" | jq -r '.[0].clobTokenIds | fromjson | .[0]')
echo $TOKEN
./cold.sh https://clob.polymarket.com/time 200 cold-time.txt
python3 pct.py cold-time.txt
./cold.sh "https://clob.polymarket.com/book?token_id=$TOKEN" 200 cold-book.txt
python3 pct.py cold-book.txt

/time returns Polymarket's clock and /book the token's order book. Each run takes a little over a minute. The median, p50, is the time half the requests beat; p99 is the slowest request in a hundred. Our /book run, in milliseconds:

The /time run had a similar median, 50.1 ms, but a p99 of 362.8 ms. One connection waited 1.8 seconds just to connect, which looks like a packet lost during setup: TCP waits about a second before it sends the first packet again.

Step 4: keep one connection open

A real bot reuses its HTTPS connection. warm.py does the same and skips the first request, which pays for the setup:

# as the bot user, in ~/lab
cat > warm.py <<'EOF'
#!/usr/bin/env python3
"""warm.py HOST PATH COUNT - time requests over one kept-open HTTPS connection (how a bot works)."""
import http.client
import sys
import time

host, path, count = sys.argv[1], sys.argv[2], int(sys.argv[3])
conn = http.client.HTTPSConnection(host, timeout=10)
times, codes = [], set()
for i in range(count + 1):
    start = time.perf_counter()
    conn.request("GET", path, headers={"User-Agent": "latency-test/1.0"})
    resp = conn.getresponse()
    resp.read()
    elapsed = (time.perf_counter() - start) * 1000
    codes.add(resp.status)
    if i > 0:                      # the first request also opens the connection, skip it
        times.append(elapsed)
    time.sleep(0.3)
times.sort()
p = lambda q: times[max(0, int(round(q / 100 * len(times))) - 1)]
print(f"{host}{path[:40]}  n={len(times)} codes={sorted(codes)}  "
      f"p50={p(50):.1f} p95={p(95):.1f} p99={p(99):.1f} max={times[-1]:.1f} ms")
EOF
python3 warm.py clob.polymarket.com /time 200
python3 warm.py clob.polymarket.com "/book?token_id=$TOKEN" 200

# our output
clob.polymarket.com/time  n=200 codes=[200]  p50=25.8 p95=33.4 p99=41.9 max=145.2 ms
clob.polymarket.com/book?token_id=3472241060806285469710686  n=200 codes=[200]  p50=26.9 p95=41.9 p99=78.1 max=83.5 ms

Reusing the connection cut the /book median from 52.2 to 26.9 ms.

Step 5: time the WebSocket feed

ws_ping.py subscribes to the token on the public market channel, waits for the first order book snapshot, then sends 150 PING messages half a second apart and times each PONG:

# as the bot user, in ~/lab
python3 -m venv ~/venv
~/venv/bin/pip install websockets
cat > ws_ping.py <<'EOF'
#!/usr/bin/env python3
"""ws_ping.py TOKEN_ID COUNT - connect to the public market channel, subscribe, then time PING/PONG."""
import asyncio
import json
import sys
import time

import websockets

URL = "wss://ws-subscriptions-clob.polymarket.com/ws/market"


async def main(token, count):
    t0 = time.perf_counter()
    async with websockets.connect(URL, ping_interval=None) as ws:
        t_open = time.perf_counter()
        await ws.send(json.dumps({"assets_ids": [token], "type": "market"}))
        first = await ws.recv()
        t_first = time.perf_counter()
        kind = json.loads(first)
        kind = kind[0]["event_type"] if isinstance(kind, list) else kind.get("event_type")
        print(f"connect {1000*(t_open-t0):.1f} ms, first message ({kind}) after {1000*(t_first-t_open):.1f} ms")
        rtts = []
        for _ in range(count):
            start = time.perf_counter()
            await ws.send("PING")
            while (await ws.recv()) != "PONG":
                pass                        # skip market updates that arrive in between
            rtts.append((time.perf_counter() - start) * 1000)
            await asyncio.sleep(0.5)
        rtts.sort()
        p = lambda q: rtts[max(0, int(round(q / 100 * len(rtts))) - 1)]
        print(f"PING/PONG n={len(rtts)} p50={p(50):.1f} p95={p(95):.1f} p99={p(99):.1f} max={rtts[-1]:.1f} ms")

asyncio.run(main(sys.argv[1], int(sys.argv[2])))
EOF
~/venv/bin/python ws_ping.py "$TOKEN" 150

pip installed websockets 17.2, and after about 80 seconds the script printed connect 146.8 ms, first message (book) after 14.4 ms and PING/PONG n=150 p50=12.3 p95=18.6 p99=29.8 max=104.4 ms. Opening the WebSocket is slow, but you do it once; after that, a round trip is half the REST time.

Step 6: trace the path to London

# as the bot user, in ~/lab
mtr -4 -r -w -z -b -c 100 clob.polymarket.com
mtr -4 -r -w -z -b -c 100 ec2.eu-west-2.amazonaws.com
./cold.sh https://ec2.eu-west-2.amazonaws.com/ 100 aws-london.txt
python3 pct.py aws-london.txt
./cold.sh https://ec2.eu-west-1.amazonaws.com/ 100 aws-dublin.txt
python3 pct.py aws-dublin.txt

mtr is a traceroute that repeats; as a normal user it sends one probe per second, so each report takes 100 seconds. The path to Polymarket went straight into Cloudflare and ended at 1.5 ms on average. The path to AWS London crossed AS7578, whose router names point to Nikhef in Amsterdam and Telehouse North in London at 5.5 ms, and then AWS ignored the probes. So the last four lines time a TCP connect to AWS's EC2 API endpoints, whose addresses belong to eu-west-2 and eu-west-1 in AWS's published ip-ranges.json: 7.3 ms to London and 15.8 ms to Dublin at the median. The HTTP 301 they return is normal.

All results in one table

The 1.3 ms is the distance to Cloudflare's door, not to the order book. One Dublin VPS seller lists 0.83 to 0.91 ms to Polymarket's API hosts without saying how it measured (vendor page, checked 12 October 2026); we got the same kind of figure from Amsterdam. The WebSocket round trip is closer to the real distance: most likely about 7 ms of network to London plus Cloudflare and Polymarket's processing. That processing time should be the same from any city, so moving a server only shrinks the network part. Every outlier above 300 ms came from opening a new connection.

Repeat the test from Dublin or Prishtina

Our lab server is in Amsterdam, so there are no Dublin numbers here, and we won't guess them. To compare a city, run Steps 1 to 6 there unchanged and check three lines against ours: the WebSocket p50 (12.3 ms), the kept-open REST p50 (25.8 ms) and the TCP connect to ec2.eu-west-2.amazonaws.com (7.3 ms). Run the set at two times of day, because tails grow when networks are busy. The same steps work for other prediction markets: swap in their API host and live feed, and read their rules for your country first.

For Prishtina, our Forex VPS page lists ping.pe probes from 6 October 2026: 40.2 ms from London to our Prishtina servers and 6.7 ms to Amsterdam. That suggests a WebSocket round trip about 30 ms longer than ours, an estimate rather than a measurement, and for a watcher, alerts or research it makes no practical difference.

Does latency matter for your bot?

If a strategy really needs the lowest latency, Polymarket offers co-location in eu-west-2 to market makers and own-account traders who complete its KYC/KYB form. That route runs through Polymarket's identity checks, and it is the only legitimate way to get that close.

What hurts a bot more than distance

• The slowest requests do more harm than the median. Our worst new connection took 2,266 ms against a 50 ms median, so give every call a timeout and a retry.
• Polling wastes time. Reuse one HTTPS connection, take live prices from the WebSocket and send related orders as one batch; POST /orders takes 1 to 15 signed orders per call (place orders docs).
• Cloudflare allows 9,000 CLOB requests per 10 seconds per IP address and 1,500 for /book, and it delays the excess instead of rejecting it, which looks like latency (rate limits).
• Per-signer limits allow 40 orders and 80 cancels per second at the Standard tier. They started on 24 July 2026 in a warning mode planned for two weeks, and Polymarket says it will announce live enforcement; after that, going over returns HTTP 429 with a Retry-After header (trading rate limits).
• While the matching engine restarts, order requests return HTTP 425, and for two minutes afterwards only post-only orders, which rest on the book instead of matching at once, are accepted (restart docs). Notices go to the Trading APIs Telegram channel.
• A bot without heartbeats can leave orders behind when it dies. Once a bot sends order heartbeats, Polymarket cancels all its open orders if none arrives within 10 seconds; the docs say to send one every 5 seconds.
• After a reconnect, the market making docs say to fetch open orders and recent trades before the strategy resumes.

Setup checklist: run the bot as a service

This skeleton follows order books and logs the best bid and ask, from public data only, and runs in the ~/venv from Step 5; your logic goes in later. It sends the PING every 10 seconds, treats 30 seconds of silence as a dead link, reconnects with growing, slightly random pauses and raises an alert after 60 seconds without data.

1. The code

# as the bot user
mkdir -p ~/pm-watch
cat > ~/pm-watch/watch.py <<'EOF'
#!/usr/bin/env python3
"""pm-watch: follows the public order book of outcome tokens and logs the best bid and ask.
Public data only: it never signs anything, never trades and needs no wallet or API key."""
import asyncio
import json
import os
import random
import time
import urllib.parse
import urllib.request

import websockets

URL = os.environ.get("WS_URL", "wss://ws-subscriptions-clob.polymarket.com/ws/market")
TOKENS = os.environ["TOKEN_IDS"].split(",")
TG_TOKEN, TG_CHAT = os.environ.get("TG_TOKEN"), os.environ.get("TG_CHAT")
state = {"down_since": None, "alerted": False}


def log(msg):
    print(msg, flush=True)                      # systemd keeps everything we print in the journal


def alert(text):
    log("ALERT " + text)
    if TG_TOKEN and TG_CHAT:
        data = urllib.parse.urlencode({"chat_id": TG_CHAT, "text": text}).encode()
        try:
            urllib.request.urlopen(f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage", data=data, timeout=10)
        except Exception as exc:
            log(f"telegram failed: {exc}")


async def keepalive(ws):
    while True:
        await asyncio.sleep(10)                 # Polymarket asks for a PING every 10 seconds
        await ws.send("PING")


async def session():
    async with websockets.connect(URL, ping_interval=None, open_timeout=10) as ws:
        await ws.send(json.dumps({"assets_ids": TOKENS, "type": "market", "custom_feature_enabled": True}))
        if state["alerted"]:
            alert("pm-watch: market data is back")
        state.update(down_since=None, alerted=False)
        log(f"connected, watching {len(TOKENS)} token(s)")
        pinger = asyncio.create_task(keepalive(ws))
        try:
            while True:
                raw = await asyncio.wait_for(ws.recv(), timeout=30)   # 30 s of silence = dead link
                if raw == "PONG":
                    continue
                events = json.loads(raw)
                for ev in events if isinstance(events, list) else [events]:
                    kind = ev.get("event_type")
                    if kind == "book":
                        log(f"{ev['asset_id'][:10]} snapshot: {len(ev['bids'])} bids, {len(ev['asks'])} asks")
                    elif kind == "best_bid_ask":
                        log(f"{ev['asset_id'][:10]} bid {ev['best_bid']} ask {ev['best_ask']}")
        finally:
            pinger.cancel()


async def main():
    delay = 1
    while True:
        started = time.monotonic()
        try:
            await session()
            reason = "server closed the connection"
        except Exception as exc:
            reason = f"{type(exc).__name__}: {exc}"
        if time.monotonic() - started > 60:
            delay = 1                           # it ran for a while: start the backoff from 1 s again
        state["down_since"] = state["down_since"] or time.monotonic()
        if time.monotonic() - state["down_since"] > 60 and not state["alerted"]:
            alert(f"pm-watch: no market data for over 60 s ({reason})")
            state["alerted"] = True
        wait = delay + random.uniform(0, delay / 2)   # jitter, so many bots don't retry in step
        log(f"disconnected ({reason}), retrying in {wait:.1f} s")
        await asyncio.sleep(wait)
        delay = min(delay * 2, 60)


asyncio.run(main())
EOF

2. Secrets in a file only root can read

# as root
install -m 600 /dev/null /etc/pm-watch.env
cat >> /etc/pm-watch.env <<'EOF'
TOKEN_IDS=PASTE_THE_TOKEN_ID_HERE
# TG_TOKEN=123456:your-bot-token
# TG_CHAT=your-chat-id
EOF
ls -l /etc/pm-watch.env

Before you paste the block, replace PASTE_THE_TOKEN_ID_HERE with the ID that echo $TOKEN printed; several IDs go comma-separated. ls shows -rw------- 1 root root, and in our lab the bot user got "Permission denied" reading it. systemd reads it as root and passes the values to the bot. A trading bot's API secret belongs in a file like this, never in code or Git.

3. The systemd service

# as root
cat > /etc/systemd/system/pm-watch.service <<'EOF'
[Unit]
Description=Polymarket public order book watcher
After=network-online.target
Wants=network-online.target

[Service]
User=bot
EnvironmentFile=/etc/pm-watch.env
ExecStart=/home/bot/venv/bin/python /home/bot/pm-watch/watch.py
Restart=always
RestartSec=5
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=read-only
PrivateTmp=yes

[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable --now pm-watch
journalctl -u pm-watch -n 20

Restart=always brings the bot back after a crash. NoNewPrivileges, ProtectSystem and ProtectHome stop it from gaining privileges or writing to system and home folders, and PrivateTmp gives it a /tmp of its own. The log showed connected, watching 1 token(s), 3472241060 snapshot: 45 bids, 33 asks and later 3472241060 bid 0.61 ask 0.62, with 18.7 MB of memory in use.

4. Break it on purpose

# as root
ss -K dport = 443
sleep 5
journalctl -u pm-watch -n 3 -o cat
echo 'WS_URL=wss://127.0.0.1:9/ws/market' >> /etc/pm-watch.env
systemctl restart pm-watch
sleep 120
journalctl -u pm-watch -n 5 -o cat
sed -i '/^WS_URL=/d' /etc/pm-watch.env
systemctl restart pm-watch

ss -K cuts every outgoing HTTPS connection on the server, so try it before the server has other work. The log said disconnected (ConnectionClosedError: no close frame received or sent), retrying in 1.2 s, and a second later the bot was back with a fresh snapshot. Pointed at a closed port, its pauses grew to 11.4, 23.2 and 36.9 seconds, then it logged ALERT pm-watch: no market data for over 60 s. The last two lines restore it.

5. Before you call it done

• Alerts reach your phone: uncomment the two Telegram lines and fill them in. Our Telegram bot guide shows how to get a token from @BotFather and your chat ID.
• Something outside the server watches it, such as Uptime Kuma or Grafana, because a dead server can't send its own alert.
• SSH accepts keys only, as in our Debian 13 hardening guide.
• A trading bot also sends heartbeats, handles HTTP 425 and 429, and uses a wallet that holds only what it can afford to lose.

Where to put a Polymarket bot: plan and city

Our watcher used 17 to 26 MB of memory under systemd, and the whole container had 35 to 41 MB in use. Size the server for what you add around the bot:

VPS plans share vCPUs with other servers on the host; VDS plans have dedicated vCPUs, which removes one cause of p99 spikes, waiting for CPU time (how to spot it). All plans run on KVM with NVMe, unmetered traffic and their own IPv4 and IPv6, and you can move up a plan later from the client area with a short reboot.

Amsterdam gave the numbers above and suits market data, research and alerts. We have not measured from Dublin. Prishtina is about 40 ms from London by the probes above, which is close enough for watchers, alerts and research. For people who live in Kosovo, Kosovo was not on Polymarket's restricted lists on 12 October 2026; the terms say the list can change without notice, so check it yourself. If you live in the Netherlands or Ireland, our servers there suit other bots, such as crypto exchange bots built with Claude Code or MetaTrader on a Forex VPS, but no server makes Polymarket trading allowed for you. Availability by city is on the plans page.

Frequently asked questions

Where are Polymarket's servers located?

Polymarket's documentation gives eu-west-2, the AWS region in London, as the region of its primary servers, and all API hosts sit behind Cloudflare. A ping or TCP connection only reaches the nearest Cloudflare data centre: a TCP connect took 1.3 ms from our Amsterdam server on 12 October 2026, while a WebSocket round trip to the order book feed took 12.3 ms.

What is the best VPS location for a Polymarket bot?

For an eligible market maker, Polymarket's own route is co-location in London (AWS eu-west-2) after a KYC/KYB check. For alerts, research and slow strategies, any European city works, because the 150 ms taker delay on crypto markets is far larger than the network gap between European cities. No server location makes trading allowed for a restricted person.

Can I use a VPS or VPN to reach Polymarket from a restricted country?

No. Polymarket's terms prohibit VPNs and similar tools used to get around its restrictions, and a VPS used that way is the same thing. Eligibility depends on where you live, where you are, your citizenship and where your company is registered, and Polymarket can put an offending wallet in close-only mode.

Does a Polymarket bot need sub-millisecond latency?

Almost never. Ads quoting under 1 ms most likely measure the trip to Cloudflare, not to the order book in London. Market makers gain from lower latency, but taker orders on crypto markets wait 150 ms anyway, and slow strategies gain nothing.

What are Polymarket's API rate limits?

Per IP address, the CLOB API allows 9,000 requests per 10 seconds, and 1,500 for /book; Cloudflare delays the excess. Per signer, the Standard tier allows 40 orders per second with bursts of 60, and 80 cancels per second with bursts of 120; these began in a warning mode on 24 July 2026, and Polymarket says it will announce when they are enforced.

How much RAM does a Polymarket bot need?

Very little. Our Python watcher used 17 to 26 MB of memory, and its whole container stayed under 45 MB, so a 1 GB VPS runs several. Databases, dashboards and many tracked markets are what need a bigger plan.

Measure first, then pick the city

Check the rules for yourself first: where you live, your citizenship and Polymarket's current list. If you may trade, run the six steps from any server you consider and compare WebSocket and REST medians, not a ping. Then run the bot as a service with a secrets file only root can read, a reconnect loop and alerts. To test from Amsterdam, Dublin or Prishtina, pick a plan on the plans page or message us on Telegram; if you want us to set up the server, we quote that work per job.

← All articles