NBA bots for Polymarket are automated trading agents that buy and sell outcome shares on NBA prediction markets using Polymarket’s CLOB (Central Limit Order Book) API. Unlike sportsbook bots that generate bet recommendations without execution access, Polymarket NBA bots can place, amend, and cancel orders programmatically through the py-clob-client SDK, trading USDC-denominated YES/NO contracts on outcomes like NBA championships, conference winners, MVP races, and playoff series.
This is a fundamentally different game from NBA betting on DraftKings or BetOnline. On Polymarket, you are a trader on an order book, not a bettor placing wagers with a bookmaker. You can go long or short. You can exit positions before resolution. You can provide liquidity and earn the spread. And the entire infrastructure – from order placement to settlement – is accessible via API.
If you are building an NBA trading agent for Polymarket, or evaluating whether Polymarket’s NBA markets are worth the engineering effort, this guide covers the complete landscape: market types, bot categories, integration code, NBA-specific strategies, architecture, and realistic expectations.
For background on how Polymarket’s CLOB works at the protocol level, see the Polymarket API Guide. For the sportsbook-focused NBA bot guides, see NBA Bot for DraftKings and NBA Bot for BetOnline. For cross-platform strategies spanning sportsbooks and prediction markets, see Cross-Platform Arbitrage and Sports Betting vs. Prediction Markets.
Why Polymarket for NBA Trading
Most sportsbooks explicitly prohibit bot activity, offer no public API for bet placement, and structure their product around a house-edge model where the book always wins in aggregate. Polymarket is the opposite on every axis that matters for automation.
Full CLOB API with Programmatic Access
Polymarket exposes a complete CLOB API with REST endpoints for order management and WebSocket feeds for real-time orderbook updates. You can place limit orders, market orders, batch orders, cancel orders, and stream price data – all programmatically. This is not a workaround or a Terms of Service violation. Polymarket was built for algorithmic trading. The py-clob-client Python SDK wraps this API with typed interfaces for authentication, order creation, and data retrieval.
DraftKings has no public betting API. BetOnline requires browser automation to place wagers. On Polymarket, your bot is a first-class participant in the market. For NBA trading specifically, this means your championship futures model can execute directly – no manual bet placement, no copy-pasting into an app, no browser automation that violates Terms of Service.
Binary Contract Structure
Every Polymarket market is a binary contract. You buy YES or NO shares priced between $0.01 and $0.99. If your side wins, the share resolves to $1.00. If it loses, it resolves to $0.00. The price of a YES share is the market’s implied probability of that outcome.
For NBA markets, this means “Celtics to win NBA Championship” might trade at $0.18, implying an 18% probability. You can buy YES shares at $0.18 and profit $0.82 per share if the Celtics win, or you can buy NO shares at $0.82 and profit $0.18 per share if they don’t. You can also sell shares you already hold at any time before resolution – a critical difference from sportsbooks where your bet is locked until the event concludes.
This two-sided structure is the key architectural difference. On DraftKings, you place a bet on the Celtics to win the title at +450 and either collect in June or lose your stake. On Polymarket, you hold a position that fluctuates in value as the season unfolds. When the Celtics win a playoff series, your YES shares appreciate. You can sell some shares to lock in profit, hold others, or add to your position. This is trading, not betting.
You Can Both Buy and Sell Positions
On a sportsbook, if you bet the Lakers at +800 to win the championship and then they lose their best player to a season-ending injury, your bet is dead money. You cannot exit. On Polymarket, you sell your Lakers YES shares – at a loss, since the price will have dropped after the injury news, but you recover partial value instead of riding a doomed position to zero.
This ability to exit positions changes the calculus for NBA futures. You can trade around events: buy before a favorable stretch of schedule, sell into a price run-up, buy back on a dip after a mid-season losing streak. NBA futures on Polymarket are tradeable instruments, not static wagers.
Lower Cost Structure
Polymarket charges 2% on net winnings. That’s it. There is no vig baked into the odds because the odds are set by traders, not a bookmaker. Compare this to sportsbooks, where NBA championship futures carry 15-25% overround across the full field. On individual game moneylines, the standard overround is 4.5% (-110 on both sides). Over hundreds of trades, this cost difference compounds substantially.
For an NBA bot running 100+ trades across a season of futures and playoff markets, the cumulative cost advantage of Polymarket’s 2% net-winnings fee versus sportsbook vig can be 5-10% of total volume traded.
Crypto-Native Infrastructure
Polymarket runs on Polygon using USDC as settlement currency. Trades settle on-chain through the Conditional Token Framework. Your bot’s wallet is its account – no KYC delays for each trade, no withdrawal processing times, no frozen accounts because a compliance team flagged your activity. Agent wallets like Coinbase Agentic Wallets integrate directly. See the agent wallet guide for setup details.
NBA Markets on Polymarket
Not every NBA outcome has a Polymarket contract. Understanding what gets listed, the liquidity profile of each market type, and the seasonal rhythm determines which bot strategies are viable.
Championship Futures
The deepest NBA liquidity on Polymarket. Championship markets open before the season and remain active through the NBA Finals in June.
- NBA Championship winner: The flagship NBA market. Top contenders (Celtics, Thunder, Nuggets) may individually have $100,000-300,000+ in cumulative volume. Long shots trade thinner but still maintain active order books.
- Each team trades as a separate binary contract. “Will the Celtics win the 2026 NBA Championship?” is a YES/NO market. “Will the Thunder win?” is a separate market. This means you can construct a portfolio of championship positions across multiple teams.
Championship futures are the core market for NBA Polymarket bots. They have the most liquidity, the longest holding periods (creating capital management challenges), and the most overlap with sportsbook futures (creating arbitrage opportunities).
Conference Winner Markets
Binary contracts for each team to win the Eastern or Western Conference. These markets have moderate liquidity – less than championship futures but more than game-level markets. Conference winner contracts become significantly more active once the playoff bracket is set, as they reduce to a four-team field per conference.
MVP and Award Markets
“Will Nikola Jokic win MVP?” and similar contracts for Defensive Player of the Year, Rookie of the Year, and other NBA awards. These markets attract interest because award races generate ongoing media narratives that create price movement opportunities. MVP markets in particular can trade actively through the All-Star break as the narrative shifts between candidates.
Playoff Round Outcomes
As the NBA playoff bracket takes shape, Polymarket lists per-round matchups. First round, conference semifinals, conference finals, and NBA Finals matchup markets all appear. These are binary – “Will the Celtics beat the Bucks in the Eastern Conference Semifinals?” – and trade from the moment the matchup is set until series completion.
Playoff markets tend to have better liquidity than regular-season game markets because Polymarket’s NBA audience is more futures-oriented. A seven-game series contract stays active for 1-2 weeks, attracting more trading attention than a single-game contract that resolves in hours.
Game-Level Markets
Polymarket does not list every regular-season NBA game. High-profile matchups – nationally televised games, Christmas Day games, marquee rivalry games – may get markets. A random Tuesday night Wizards-Hornets game is unlikely to have a Polymarket contract.
When game-level markets exist, they are typically binary (moneyline only, not spreads or totals). Liquidity is thin compared to the same game on DraftKings. This matters: thin liquidity means your bot cannot trade large sizes without moving the market, but also means wider spreads that market-makers can profit from.
Liquidity Compared to Sportsbooks and Political Markets
| Market Type | Typical Polymarket Volume | Typical Sportsbook Handle |
|---|---|---|
| NBA Championship (per team) | $50,000-300,000+ season | $500M+ across all books |
| Conference winner | $10,000-75,000 | $50M+ |
| Playoff series | $10,000-50,000 per series | $100M+ per series |
| Game-level (when listed) | $2,000-25,000 | $50M+ per game |
| MVP / Awards | $5,000-30,000 | Millions via futures books |
NBA liquidity on Polymarket is also significantly thinner than Polymarket’s own political markets. A presidential election contract might see $50M+ in volume; even the most liquid NBA championship contract is two orders of magnitude smaller. This liquidity differential shapes every strategy: you cannot deploy the same capital or use the same order sizes that work on Polymarket’s political markets.
How Markets Get Created
Polymarket markets are created by the Polymarket team and approved market creators. Unlike a sportsbook that lists every game automatically, NBA market availability depends on anticipated demand. During the NBA season, championship and award markets are persistent. Playoff markets appear as the bracket forms. Game-level markets are created selectively.
You can monitor for new NBA markets using the Gamma API, which provides market metadata, categories, and creation dates. A discovery bot that polls the Gamma API for new NBA-tagged markets and alerts when fresh contracts appear is a useful piece of infrastructure.
Bot Categories for NBA on Polymarket
Different strategies demand different bot architectures. Here are the six primary categories for NBA trading on Polymarket.
Championship Futures Arbitrage Bots
What they do: Compare Polymarket NBA championship contract prices to sportsbook futures odds for the same teams. When implied probabilities diverge enough, trade the underpriced side or execute both legs for risk-free profit.
How they work: Pull Polymarket YES prices via the CLOB API and sportsbook futures odds via The Odds API. Convert everything to implied probabilities. When Polymarket prices a team’s championship probability lower than the best sportsbook-implied probability, buy YES on Polymarket. When Polymarket prices a team higher, buy NO on Polymarket or bet against on the sportsbook.
Why it works for NBA: NBA championship futures fields have 30 teams. Sportsbooks and Polymarket serve different customer bases – crypto traders on one side, recreational bettors and sharp money on the other. These populations process information differently, creating persistent price gaps, especially early in the season and after major events like the trade deadline.
Model-Driven Directional Trading Bots
What they do: Run an NBA prediction model that generates championship, conference, and series probabilities. Trade Polymarket contracts where the model’s estimate diverges from the market price.
How they work: Build team power ratings using NBA data (offensive/defensive efficiency, Elo, strength of schedule), simulate the remaining season and playoffs using Monte Carlo methods, generate per-team championship probabilities, and compare to Polymarket contract prices. Buy underpriced shares, sell overpriced ones.
Why Polymarket is different for this: On a sportsbook, you can only bet on a team to win the championship. If you think a team is overpriced, you cannot short them (you can only not bet). On Polymarket, you can buy NO shares when you think a team’s YES price is too high. This doubles the number of actionable signals from your model. You can also adjust positions continuously as new information arrives – trade deadlines, injuries, coaching changes all shift your model output, and you can rebalance your Polymarket portfolio accordingly.
Market-Making Bots
What they do: Post buy and sell orders on both sides of an NBA market, earning the bid-ask spread on every trade that crosses.
How they work: Quote a bid price and an ask price for YES shares on an NBA contract. When someone buys at the ask, the bot sells shares at a premium. When someone sells at the bid, the bot buys shares at a discount. The difference is the bot’s revenue per round-trip.
Why it works for NBA: NBA markets on Polymarket often have wide spreads due to lower liquidity. A championship futures market might show a bid at $0.16 and an ask at $0.20 for a given team – a 4-cent spread. A market-making bot quoting $0.17 / $0.19 narrows the spread while earning 2 cents per round-trip. Across multiple NBA markets (30 championship contracts, 30 conference contracts, plus playoff series as they appear), the aggregate earning opportunity is meaningful.
Risk: Inventory risk. If you accumulate a large YES position on a team because informed traders keep selling to your bid (they know something you don’t – an impending trade, an injury report), your inventory loses value. Market-making NBA futures is not risk-free. It requires hedging logic, position limits, and the ability to detect when order flow is informational versus random.
News Reaction Bots
What they do: Monitor NBA news feeds – injury reports, trade deadline moves, coaching changes, suspension announcements – and trade Polymarket contracts before the market fully reprices.
How they work: Parse NBA injury reports, ESPN/Woj/Shams alerts, and team press releases. When a signal fires (star player season-ending injury, blockbuster trade), immediately check the relevant Polymarket contract prices and trade if the market hasn’t adjusted.
The NBA-specific edge: The NBA trade deadline (early February) is the single largest repricing event for championship futures outside of the playoffs. When a contender acquires a star at the deadline, their championship probability should jump immediately. But Polymarket’s NBA markets are thinly traded compared to sportsbooks – repricing can lag by minutes or even hours for less-watched team contracts. A bot that detects the trade and buys the acquiring team’s championship contract before the market fully adjusts captures alpha.
Similarly, a season-ending injury to an MVP candidate (torn ACL, Achilles rupture) immediately reshuffles championship probabilities for multiple teams: the injured player’s team drops, and rival teams in the same conference rise. A news bot that reprices the entire conference in seconds can trade multiple contracts simultaneously.
Copy-Trading Bots
What they do: Identify profitable wallets trading NBA markets on Polymarket and mirror their positions.
How they work: Use on-chain data (Dune Analytics, Polygon indexer, or Polymarket’s public trade feed) to identify wallets with consistently profitable NBA trading histories. Monitor those wallets in real-time. When a tracked wallet buys YES shares on “Thunder to win NBA Championship,” the copy-trading bot buys the same contract.
Limitations: The tracked wallet’s order may have already moved the price before your bot executes. The wallet’s edge may not persist. And you’re always one step behind. Copy-trading is a valid starting strategy for operators who don’t have an NBA model but want market exposure to informed trading.
Playoff Series Pricing Bots
What they do: Model game-by-game win probabilities for NBA playoff series and convert to series odds. Trade when Polymarket’s series price diverges from the bot’s calculated fair value.
How they work: Take each playoff matchup, assign a per-game win probability for each team (adjusted for home-court advantage), then calculate the probability of winning the series (4 wins needed in a best-of-7). Compare to Polymarket’s series contract price.
Why this is a distinct category: Series pricing involves combinatorial math that many market participants get wrong intuitively. A team with a 55% chance of winning any individual game has a 60.8% chance of winning a best-of-7 series – the series structure amplifies small per-game edges. If home-court advantage matters (and in the NBA it does: home teams win roughly 58-60% of playoff games historically), the correct series probability depends on the specific home-court split (2-2-1-1-1 format). A bot that models this correctly can identify when Polymarket’s series price underestimates or overestimates the favorite.
Polymarket Integration for NBA
Here is how to connect your NBA bot to Polymarket’s APIs – from discovering NBA markets to placing orders.
Discovering NBA Markets via the Gamma API
The Gamma API provides market metadata. Use it to find active NBA contracts by keyword.
import requests
GAMMA_URL = "https://gamma-api.polymarket.com"
def find_nba_markets() -> list[dict]:
"""Fetch active NBA-related markets from Polymarket."""
markets = requests.get(
f"{GAMMA_URL}/markets",
params={
"active": True,
"closed": False,
"limit": 200,
"order": "volume24hr",
"ascending": False,
}
).json()
nba_keywords = [
"NBA", "NBA Championship", "Eastern Conference", "Western Conference",
"NBA Finals", "NBA MVP", "NBA Playoff", "NBA Draft",
]
team_names = [
"Celtics", "Thunder", "Nuggets", "Cavaliers", "Knicks", "Bucks",
"Timberwolves", "Suns", "Lakers", "Warriors", "76ers", "Heat",
"Mavericks", "Pacers", "Clippers", "Rockets", "Kings", "Pelicans",
"Magic", "Grizzlies", "Nets", "Bulls", "Hawks", "Raptors",
"Spurs", "Trail Blazers", "Jazz", "Pistons", "Hornets", "Wizards",
]
all_terms = nba_keywords + team_names
nba_markets = []
for market in markets:
question = market.get("question", "")
if any(term.lower() in question.lower() for term in all_terms):
nba_markets.append({
"question": question,
"condition_id": market.get("conditionId"),
"tokens": market.get("clobTokenIds", []),
"volume": market.get("volume", 0),
"last_price": market.get("outcomePrices", []),
"end_date": market.get("endDate"),
})
return nba_markets
nba = find_nba_markets()
for m in nba:
print(f"{m['question']} — Volume: ${float(m['volume']):,.0f}")
The Gamma API does not have a dedicated “NBA” category filter – you search by keywords in the market question. A production bot would maintain a curated mapping of condition IDs to tracked NBA markets rather than relying on keyword matching for every poll.
Placing Orders with py-clob-client
Once you have the condition ID and token IDs for an NBA market, you trade using py-clob-client. For the full SDK reference, see the py-clob-client Reference.
from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs
import os
client = ClobClient(
host="https://clob.polymarket.com",
key=os.environ["POLYMARKET_PRIVATE_KEY"],
chain_id=137, # Polygon mainnet
)
client.set_api_creds(client.create_or_derive_api_creds())
def buy_nba_shares(token_id: str, price: float, size: float) -> dict:
"""Buy YES or NO shares on an NBA market.
Args:
token_id: The CLOB token ID for the YES or NO side.
price: Limit price ($0.01 - $0.99).
size: Number of shares to buy.
Returns:
Order result from the CLOB API.
"""
order = client.create_order(
OrderArgs(
token_id=token_id,
price=price,
size=size,
side="BUY",
)
)
return client.post_order(order)
def sell_nba_shares(token_id: str, price: float, size: float) -> dict:
"""Sell shares you hold on an NBA market.
Use this to exit a position before resolution.
"""
order = client.create_order(
OrderArgs(
token_id=token_id,
price=price,
size=size,
side="SELL",
)
)
return client.post_order(order)
# Example: Buy 200 YES shares on Celtics championship at $0.18
result = buy_nba_shares(
token_id="<CELTICS_YES_TOKEN_ID>",
price=0.18,
size=200,
)
print(f"Order placed: {result}")
For rate limit handling in production, see the Polymarket Rate Limits Guide. For the quickstart tutorial, see Polymarket Trading Bot Quickstart.
Combining Polymarket Data with NBA Stats API
The modeling side of your bot draws from the NBA’s official statistical data through the nba_api Python package. Combining Polymarket market data with NBA statistical modeling is the core loop for any model-driven NBA Polymarket bot.
from nba_api.stats.endpoints import leaguedashteamstats
def get_team_ratings(season: str = "2025-26") -> dict:
"""Fetch team offensive/defensive efficiency and pace.
These ratings form the foundation of championship probability models.
"""
stats = leaguedashteamstats.LeagueDashTeamStats(
season=season,
measure_type_detailed_defense="Advanced",
per_mode_detailed="Per100Possessions",
)
df = stats.get_data_frames()[0]
teams = {}
for _, row in df.iterrows():
teams[row["TEAM_ABBREVIATION"]] = {
"team": row["TEAM_NAME"],
"off_rating": row["OFF_RATING"],
"def_rating": row["DEF_RATING"],
"net_rating": row["NET_RATING"],
"pace": row["PACE"],
"wins": row["W"],
"losses": row["L"],
}
return teams
NBA Strategies on Polymarket
These are the specific strategies where Polymarket’s CLOB structure and the NBA’s data-rich environment combine to give bots a structural advantage.
Championship Futures Mispricing
The highest-conviction NBA strategy on Polymarket. Build a model that generates championship probabilities for every team, then compare to Polymarket prices.
Approach:
- Build team power ratings using offensive/defensive efficiency, net rating, and strength of schedule from
nba_api. - Simulate the remaining regular season to generate playoff seedings.
- Simulate the playoff bracket using game-level win probabilities (adjusted for home-court advantage).
- Run 50,000-100,000 Monte Carlo simulations.
- Extract championship probabilities for each team.
- Compare to Polymarket contract prices.
- Trade where your model diverges from Polymarket by more than 3-4 percentage points.
import numpy as np
def simulate_championship_probabilities(
team_ratings: dict,
remaining_schedule: list[dict],
n_simulations: int = 50_000,
) -> dict[str, float]:
"""Monte Carlo simulation of NBA championship probabilities.
Simulates the remaining regular season and full playoffs.
Returns {team_abbreviation: championship_probability}.
Args:
team_ratings: {team_abbrev: {net_rating, off_rating, def_rating, ...}}
remaining_schedule: [{home, away, date}, ...]
n_simulations: Number of Monte Carlo iterations.
"""
championship_counts = {team: 0 for team in team_ratings}
for _ in range(n_simulations):
standings = simulate_remaining_season(team_ratings, remaining_schedule)
playoff_bracket = generate_playoff_bracket(standings)
champion = simulate_playoffs(playoff_bracket, team_ratings)
championship_counts[champion] += 1
total = sum(championship_counts.values())
return {
team: count / total
for team, count in championship_counts.items()
}
def simulate_game(
home_rating: float, away_rating: float, home_advantage: float = 3.0
) -> str:
"""Simulate a single NBA game using team net ratings.
Args:
home_rating: Home team net rating (points per 100 possessions).
away_rating: Away team net rating.
home_advantage: Home-court advantage in net rating points.
Returns:
'home' or 'away'.
"""
diff = home_rating - away_rating + home_advantage
home_win_prob = 1 / (1 + 10 ** (-diff / 10))
return "home" if np.random.random() < home_win_prob else "away"
def simulate_series(
team_a_rating: float,
team_b_rating: float,
home_court_team: str,
home_advantage: float = 3.0,
) -> str:
"""Simulate a best-of-7 NBA playoff series.
NBA playoff format: 2-2-1-1-1 (higher seed has home court in games 1,2,5,7).
"""
# Home team for each game (True = team_a has home court)
a_is_home = home_court_team == "a"
home_pattern = [a_is_home, a_is_home,
not a_is_home, not a_is_home,
a_is_home, not a_is_home, a_is_home]
a_wins = 0
b_wins = 0
for game_idx in range(7):
if a_wins == 4 or b_wins == 4:
break
if home_pattern[game_idx]:
winner = simulate_game(team_a_rating, team_b_rating, home_advantage)
if winner == "home":
a_wins += 1
else:
b_wins += 1
else:
winner = simulate_game(team_b_rating, team_a_rating, home_advantage)
if winner == "home":
b_wins += 1
else:
a_wins += 1
return "a" if a_wins == 4 else "b"
Where the edge comes from: Polymarket championship prices are set by trader consensus, not by a quantitative model. Early in the season, recency bias dominates: a team on a 10-game winning streak sees its championship contract bid up beyond what the underlying team quality justifies. Similarly, a contender that loses two games in a row might see its contract price dip below fair value. A model that anchors to team fundamentals (net rating, strength of schedule) rather than recent results can systematically identify these mispricings.
Playoff Series Pricing
When the playoff bracket is set, Polymarket lists series outcome contracts. The correct series price depends on per-game win probabilities and the home-court advantage structure. Many traders price series intuitively, but the math is unintuitive.
Key insight: A team with a 55% chance of winning each individual game has a 60.8% chance of winning a 7-game series. A team with 60% per-game has a 71.0% series probability. The series structure amplifies edges – and most casual traders underestimate this amplification.
from itertools import product as itertools_product
def series_probability(
game_win_probs: list[float],
) -> float:
"""Calculate exact probability of winning a best-of-7 series.
Args:
game_win_probs: List of 7 win probabilities for games 1-7,
accounting for home/away splits.
Returns:
Probability of winning the series (getting to 4 wins first).
"""
total_prob = 0.0
for outcomes in itertools_product([True, False], repeat=7):
wins = 0
losses = 0
game_prob = 1.0
series_ended = False
for game_idx, won in enumerate(outcomes):
if series_ended:
break
if won:
game_prob *= game_win_probs[game_idx]
wins += 1
else:
game_prob *= (1 - game_win_probs[game_idx])
losses += 1
if wins == 4 or losses == 4:
series_ended = True
if wins == 4:
total_prob += game_prob
return total_prob
def nba_series_fair_price(
home_win_prob: float,
away_win_prob: float,
) -> float:
"""Calculate fair series price given home/away win probabilities.
Uses NBA 2-2-1-1-1 format where the higher seed is home in games 1,2,5,7.
"""
game_probs = [
home_win_prob, # Game 1: Home
home_win_prob, # Game 2: Home
away_win_prob, # Game 3: Away
away_win_prob, # Game 4: Away
home_win_prob, # Game 5: Home
away_win_prob, # Game 6: Away
home_win_prob, # Game 7: Home
]
return series_probability(game_probs)
Application: If your model estimates the Celtics have a 62% home win probability and 52% road win probability against the Bucks, the fair series price is 65.4%. If Polymarket has the Celtics series contract at $0.58, that is a 7.4-cent mispricing – a significant edge worth trading. If Polymarket has it at $0.64, the mispricing is only 1.4 cents, which may not clear the 2% fee hurdle.
Trade Deadline Alpha
The NBA trade deadline (early February) is the largest mid-season repricing event for championship futures. When a contender acquires a star player, their championship probability should jump immediately, and the team that lost the star should drop.
How to exploit this on Polymarket:
- Monitor trade reports. Follow the Woj/Shams/Charania news pipeline. Parse breaking trade alerts programmatically via Twitter/X API or dedicated sports news feeds.
- Pre-compute repricing. Before the deadline, build a lookup table: “If Player X is traded from Team A to Team B, how does each team’s championship probability change?” Pre-computing this eliminates latency when the trade breaks.
- Execute immediately. Buy the acquiring team’s championship contract and sell (or buy NO on) the losing team’s contract. On Polymarket, where repricing is slower than on sportsbooks, you may have a window of minutes to hours.
Why Polymarket lags: Sportsbook futures are repriced by professional oddsmakers who react to trade news within seconds. Polymarket reprices only when traders actively buy or sell. During a deadline-day flurry of trades, not every affected team’s Polymarket contract gets immediate attention – a mid-tier team acquiring a key piece might not see its Polymarket price updated for an hour. That is your window.
Injury-Driven Trading
Star player injuries create massive repricing events across multiple markets simultaneously. A season-ending injury to an MVP candidate affects:
- That team’s championship contract (drops significantly)
- Conference rival championship contracts (rise)
- MVP award contracts (reshuffles entirely)
- Playoff series contracts (if applicable)
NBA-specific edge: The NBA has the highest single-player impact of any major team sport. LeBron, Giannis, Jokic, Luka – losing one of these players can shift a team’s championship probability by 10-15 percentage points. A bot that detects the injury report and trades all affected contracts simultaneously can capture alpha across multiple markets from a single information event.
Data sources: Official NBA injury reports, team press conferences, beat reporter Twitter feeds. The NBA requires teams to submit injury reports at defined times during the season, but major injuries (in-game injuries, MRI results) are reported on less predictable schedules.
Cross-Platform Arbitrage: Polymarket vs. Sportsbooks
Sportsbooks and Polymarket price NBA futures using completely different mechanisms. This structural difference creates persistent price gaps.
import requests
def compare_nba_championship_prices(
polymarket_markets: list[dict],
odds_api_key: str,
) -> list[dict]:
"""Compare Polymarket NBA championship prices to sportsbook lines.
Returns opportunities where implied probabilities diverge.
"""
sb_response = requests.get(
"https://api.the-odds-api.com/v4/sports/basketball_nba_championship/outrights",
params={
"apiKey": odds_api_key,
"regions": "us,us2",
"oddsFormat": "american",
}
)
sb_response.raise_for_status()
sb_data = sb_response.json()
def american_to_implied(odds: int) -> float:
if odds > 0:
return 100 / (odds + 100)
return abs(odds) / (abs(odds) + 100)
sb_probs = {}
for event in sb_data:
for bookmaker in event.get("bookmakers", []):
for market in bookmaker.get("markets", []):
for outcome in market.get("outcomes", []):
team = outcome["name"]
implied = american_to_implied(outcome["price"])
if team not in sb_probs or implied < sb_probs[team]["implied"]:
sb_probs[team] = {
"implied": implied,
"odds": outcome["price"],
"book": bookmaker["title"],
}
opportunities = []
for pm_market in polymarket_markets:
team = pm_market.get("team")
pm_yes_price = pm_market.get("yes_price", 0)
if team in sb_probs:
sb_implied = sb_probs[team]["implied"]
gap = abs(pm_yes_price - sb_implied)
if gap > 0.03:
cheaper_side = "Polymarket" if pm_yes_price < sb_implied else "Sportsbook"
opportunities.append({
"team": team,
"polymarket_yes": pm_yes_price,
"sportsbook_implied": round(sb_implied, 4),
"sportsbook_odds": sb_probs[team]["odds"],
"book": sb_probs[team]["book"],
"gap": round(gap, 4),
"cheaper_on": cheaper_side,
})
return sorted(opportunities, key=lambda x: x["gap"], reverse=True)
When you find a divergence, buy the underpriced side. If Polymarket has the Thunder at $0.15 (15%) and the best sportsbook line implies 20%, buy YES shares on Polymarket. The trade is directional unless you simultaneously bet the opposite side on the sportsbook – see the cross-platform arbitrage guide for the full two-legged implementation.
Architecture
Here is the architecture for a production NBA Polymarket trading agent.
┌─────────────────────────────────────────────────────────────────┐
│ DATA LAYER │
│ │
│ Gamma API ─────── NBA market discovery, condition IDs │
│ CLOB WebSocket ── Real-time orderbook, price ticks │
│ nba_api ───────── Team ratings, player stats, schedule │
│ The Odds API ──── Sportsbook lines for cross-market comparison │
│ Injury feeds ──── ESPN, NBA official reports, beat reporters │
├─────────────────────────────────────────────────────────────────┤
│ MODEL LAYER │
│ │
│ Championship simulator (Elo/net rating → Monte Carlo) │
│ Playoff series pricer (game probs → series odds) │
│ Cross-market comparator (Polymarket vs. sportsbook implied) │
│ News/injury signal parser and repricing engine │
├─────────────────────────────────────────────────────────────────┤
│ STRATEGY LAYER │
│ │
│ Signal evaluation ── Is the edge above threshold? │
│ Position sizing ──── Kelly / fractional Kelly │
│ Risk management ──── Max position, max daily spend, drawdown │
│ Portfolio logic ──── Allocate across multiple NBA markets │
│ Exit strategy ────── When to sell existing positions │
├─────────────────────────────────────────────────────────────────┤
│ EXECUTION LAYER │
│ │
│ py-clob-client ──── Place/cancel/amend orders via CLOB API │
│ Rate limiter ────── Respect Polymarket rate limits │
│ Retry logic ─────── Handle transient API failures │
│ Agent wallet ────── EIP-712 signing, USDC on Polygon │
├─────────────────────────────────────────────────────────────────┤
│ MONITORING LAYER │
│ │
│ P&L tracker ─────── Per-market and aggregate returns │
│ Position monitor ── Current exposure across all NBA contracts │
│ Share value tracker Mark-to-market on held positions │
│ Alert system ────── Telegram/Discord notifications │
│ Kill switch ─────── Emergency halt on drawdown threshold │
└─────────────────────────────────────────────────────────────────┘
The Key Difference from Sportsbook Bots: Position Management
On DraftKings, your bot’s pipeline ends at “generate a recommendation” because there is no API for execution. The human places the bet. On BetOnline, the same constraint applies. On Polymarket, the pipeline is end-to-end automated: data ingestion, model computation, signal evaluation, order placement, position management, and exit – all programmatic.
This also means you need to handle the full lifecycle of a trade. On a sportsbook, you place a championship futures bet in November and wait until June. On Polymarket, you might:
- Buy 500 YES shares on the Celtics at $0.15 in November
- Sell 200 shares at $0.22 in January after a strong first half
- Buy 300 more shares at $0.19 in February after a minor slump
- Sell 400 shares at $0.30 in April after they clinch the #1 seed
- Hold the remaining 200 through the playoffs
- Shares resolve to $1.00 (championship win) or $0.00 (eliminated)
Your bot needs order tracking, position management, mark-to-market accounting, and exit logic – not just signal generation. Shares you hold fluctuate in value daily. Your P&L is not just “win or lose” – it is a continuous function of position sizes and current market prices.
Python Class Skeleton
from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs
import os
import requests
from dataclasses import dataclass, field
GAMMA_URL = "https://gamma-api.polymarket.com"
@dataclass
class NBAPosition:
market_question: str
token_id: str
side: str # "YES" or "NO"
shares: float
avg_entry_price: float
current_price: float = 0.0
@property
def unrealized_pnl(self) -> float:
return (self.current_price - self.avg_entry_price) * self.shares
@property
def market_value(self) -> float:
return self.current_price * self.shares
class NBAPolymarketBot:
"""NBA trading bot for Polymarket's CLOB."""
def __init__(
self,
max_position_usd: float = 500,
max_daily_spend: float = 1000,
min_edge: float = 0.04,
):
self.client = ClobClient(
host="https://clob.polymarket.com",
key=os.environ["POLYMARKET_PRIVATE_KEY"],
chain_id=137,
)
self.client.set_api_creds(self.client.create_or_derive_api_creds())
self.max_position_usd = max_position_usd
self.max_daily_spend = max_daily_spend
self.min_edge = min_edge
self.daily_spend = 0.0
self.positions: dict[str, NBAPosition] = {}
def discover_nba_markets(self) -> list[dict]:
"""Find active NBA markets on Polymarket."""
markets = requests.get(
f"{GAMMA_URL}/markets",
params={"active": True, "closed": False, "limit": 200}
).json()
nba_terms = [
"nba", "nba championship", "eastern conference", "western conference",
"nba finals", "nba mvp", "nba playoff",
]
return [
m for m in markets
if any(t in m.get("question", "").lower() for t in nba_terms)
]
def evaluate_signal(
self, token_id: str, model_prob: float
) -> dict | None:
"""Compare model probability to Polymarket price.
Returns trade signal if edge exceeds threshold.
"""
book = self.client.get_order_book(token_id)
if not book.asks:
return None
best_ask = float(book.asks[0].price)
edge = model_prob - best_ask
if edge > self.min_edge:
return {
"token_id": token_id,
"side": "BUY",
"price": best_ask,
"edge": edge,
"model_prob": model_prob,
}
best_bid = float(book.bids[0].price) if book.bids else None
if best_bid and (best_bid - model_prob) > self.min_edge:
return {
"token_id": token_id,
"side": "SELL",
"price": best_bid,
"edge": best_bid - model_prob,
"model_prob": model_prob,
}
return None
def execute_trade(
self, token_id: str, price: float, size: float, side: str = "BUY"
) -> dict | None:
"""Execute a trade with risk checks."""
cost = price * size
if cost > self.max_position_usd:
size = self.max_position_usd / price
if self.daily_spend + cost > self.max_daily_spend:
return None
order = self.client.create_order(
OrderArgs(
token_id=token_id,
price=price,
size=size,
side=side,
)
)
result = self.client.post_order(order)
self.daily_spend += cost
return result
def close_position(self, token_id: str) -> dict | None:
"""Sell all shares held for a given token."""
pos = self.positions.get(token_id)
if not pos or pos.shares <= 0:
return None
book = self.client.get_order_book(token_id)
if not book.bids:
return None
best_bid = float(book.bids[0].price)
order = self.client.create_order(
OrderArgs(
token_id=token_id,
price=best_bid,
size=pos.shares,
side="SELL",
)
)
return self.client.post_order(order)
def calculate_kelly_size(self, edge: float, price: float) -> float:
"""Half-Kelly position sizing for binary contracts."""
if price <= 0 or price >= 1:
return 0
full_kelly = edge / (1.0 - price)
half_kelly = full_kelly / 2
bankroll = self.max_daily_spend - self.daily_spend
return max(0, bankroll * half_kelly / price)
def portfolio_summary(self) -> dict:
"""Summarize current NBA portfolio on Polymarket."""
total_cost = sum(
p.avg_entry_price * p.shares for p in self.positions.values()
)
total_value = sum(p.market_value for p in self.positions.values())
total_pnl = sum(p.unrealized_pnl for p in self.positions.values())
return {
"num_positions": len(self.positions),
"total_cost_basis": round(total_cost, 2),
"total_market_value": round(total_value, 2),
"unrealized_pnl": round(total_pnl, 2),
"positions": {
tid: {
"question": p.market_question,
"shares": p.shares,
"entry": p.avg_entry_price,
"current": p.current_price,
"pnl": round(p.unrealized_pnl, 2),
}
for tid, p in self.positions.items()
},
}
def run_cycle(self, model_outputs: dict[str, float]):
"""Run one evaluation cycle.
Args:
model_outputs: {token_id: model_probability} from your NBA model.
"""
for token_id, model_prob in model_outputs.items():
signal = self.evaluate_signal(token_id, model_prob)
if signal:
size = self.calculate_kelly_size(signal["edge"], signal["price"])
if size > 0:
result = self.execute_trade(
token_id, signal["price"], size, signal["side"]
)
if result:
print(
f"Traded {token_id}: {signal['side']} {size:.0f} "
f"shares @ {signal['price']}"
f" (edge: {signal['edge']:.1%})"
)
This skeleton is a starting point. A production implementation adds: persistent position storage (database), multi-market scanning on a scheduler, WebSocket-driven price monitoring, logging, and the full monitoring layer described in the architecture diagram. For position sizing details, see Kelly Criterion Bot.
Agent Wallet and Infrastructure
Polymarket requires a wallet that holds USDC on Polygon and can produce EIP-712 signatures. For autonomous NBA trading agents, this means configuring a wallet that operates without human intervention.
USDC on Polygon
Your agent needs USDC on the Polygon network. Options for funding:
- Direct withdrawal from Coinbase to Polygon: The simplest path. Coinbase supports USDC withdrawals directly to Polygon addresses with minimal fees.
- Bridge from Ethereum: Use the Polygon PoS Bridge, Across Protocol, or Jumper for cross-chain transfers. Costs $1-15 depending on Ethereum gas.
- Bridge from other L2s: Across and Jumper support Base, Arbitrum, and Optimism to Polygon routes.
Agent Wallet Options for NBA Trading
For autonomous operation, your bot needs its private key accessible without human interaction. The standard approaches, from simplest to most secure:
- Environment variable: Store the private key in an environment variable. Simplest but least secure – anyone with server access can read it.
- Secrets manager: AWS Secrets Manager, GCP Secret Manager, or HashiCorp Vault. The bot fetches the key at startup. Better for production.
- Coinbase Agentic Wallet: Purpose-built for autonomous agents. Provides built-in spending limits, key management, and audit logging. See the agent wallet guide for setup.
Bankroll Allocation Across Multiple NBA Markets
NBA futures trading on Polymarket ties up capital for extended periods. A championship contract bought in November does not resolve until June – seven months of capital lockup. This creates a bankroll allocation problem that does not exist for nightly sportsbook betting.
Guidelines:
- Never allocate more than 10-15% of your Polymarket bankroll to a single NBA market. Championship futures are high-variance. Even if your model says the Celtics have a 25% championship probability and Polymarket has them at 18%, a 7-cent edge on a contract that resolves to $0 three-quarters of the time demands conservative sizing.
- Reserve capital for playoff markets. Playoff series contracts offer shorter holding periods (1-2 weeks) and faster capital turnover. If you allocate 100% of your bankroll to championship futures in November, you have nothing left when higher-liquidity playoff markets appear in April.
- Account for the opportunity cost. Capital sitting in NBA championship YES shares at $0.18 is capital that cannot be deployed on a political market with a 10% edge or a crypto market with high turnover. Factor cross-market opportunity cost into your NBA allocation decisions.
Security
An NBA trading agent with access to your wallet can drain it. Implement defense in depth:
- Application-level: Max order size, max daily spend, max position per market (as shown in the class skeleton above).
- Wallet-level: Coinbase Agentic Wallets support policy-based spending caps.
- Monitoring: Alerts via Telegram or Discord when spend exceeds thresholds. A remote kill switch that cancels all open orders and stops the bot.
- Separate wallets: Use a dedicated wallet for your NBA bot with only the capital you are willing to risk.
For comprehensive security guidance, see the agent wallet guide.
Realistic Expectations
NBA trading on Polymarket is not a money printer. Here is an honest assessment of what to expect.
NBA Futures Liquidity Is Thin
The most important constraint. NBA markets on Polymarket have a fraction of the liquidity you find on sportsbooks or even on Polymarket’s political markets.
This means:
- Large orders move the market. A $5,000 market order on a mid-tier team’s championship contract can move the price 5-10 cents.
- Slippage is real. Your limit order at $0.18 might sit unfilled for hours if there is no one willing to sell at that price.
- Total addressable capital is limited. You cannot deploy $100,000 into Polymarket NBA markets without becoming the market. Realistic maximum bankroll for NBA-specific Polymarket trading: $5,000-20,000, depending on how many markets you spread across.
Market Efficiency Improves as Playoffs Approach
Early in the NBA season (October-December), Polymarket championship prices are more likely to be mispriced. Fewer traders are watching, volume is lower, and public sentiment overweights preseason narratives. As the season progresses and playoff positioning becomes clearer, prices converge toward efficient levels. By the conference finals, the remaining contracts attract enough attention that mispricings are small and fleeting.
Implication for bot operators: The best edge-per-trade exists early in the season, but execution is hardest (lowest liquidity). The most liquid markets (late playoffs, Finals) have the least mispricing. Your bot’s annual profit is front-loaded toward the October-February window for championship futures, and concentrated in the April-June window for series pricing.
The 2% Fee Impact on Narrow Edges
Polymarket charges 2% on net winnings (profit, not volume). For NBA strategies with narrow edges, this fee is material.
Example: You buy 500 YES shares at $0.18 ($90 cost). The contract resolves to $1.00, netting $410 in gross profit. The 2% fee on that $410 is $8.20. Manageable.
But if you are trading in and out – buying at $0.18, selling at $0.22 – the 2% applies to your $20 net profit on that round-trip, taking $0.40. On a 4-cent edge captured across 500 shares, the fee is $0.40 out of $20.00 gross profit – a 2% drag that reduces your edge from 4 cents to 3.92 cents. For higher-frequency strategies with smaller per-trade edges, the fee eats a larger percentage.
Holding Period Risk
NBA championship futures tie up capital for months. During that time:
- Your capital is illiquid (you can sell, but at market price, which may be worse than entry).
- The opportunity cost of locked capital applies.
- Events outside your model (injuries, trades, coaching changes) can destroy your position’s value.
- Polymarket itself is a counterparty – platform risk is non-zero.
This holding period risk is fundamentally different from nightly sportsbook betting where your capital is returned (or lost) within hours. Factor this into your expected return calculations. A 15% annual return on capital locked for 7 months in championship futures has a different risk profile than a 15% return generated from nightly sports bets with overnight capital turnover.
Realistic Return Expectations
Market-making on NBA markets depends on spread width and volume. In thin NBA markets, you might earn wide spreads (4-6 cents) but trade infrequently. Realistic annualized returns on deployed capital: 5-15% in favorable conditions, with periods of significant inventory drawdown.
Directional trading depends entirely on your model’s accuracy. A model that correctly identifies 3-5 percentage point mispricings in championship or series prices, traded with Kelly sizing, might generate 10-30% returns on deployed capital over an NBA season. But variance is enormous: one bad model assumption (overrating a team that gets injured, underrating a trade deadline move) can erase months of profits.
Arbitrage returns are bounded by the frequency and size of cross-platform price gaps. True risk-free arbs are rare and narrow. Quasi-arbs (directional bets on the cheaper side) are more common but carry risk. Realistic arbitrage returns on a $5,000-10,000 bankroll: $200-800 per NBA season.
What Does Not Work
- High-frequency trading on NBA markets. There is not enough volume. NBA championship contracts might see only a few trades per hour during the regular season. HFT strategies need continuous order flow that NBA markets on Polymarket do not provide.
- Game-level scalping. Polymarket’s NBA game-level markets (when they exist) do not have the depth or repricing speed to support in-play scalping. This is not a sportsbook with continuous live odds.
- Copying political market strategies directly. Political markets on Polymarket have different liquidity dynamics, information sources, and repricing behavior. A market-making bot calibrated for a presidential election contract will not perform the same way on an NBA championship contract.
- Ignoring the capital lockup. A 20% edge on a championship future sounds great until you realize the capital is locked for six months and you could have deployed it across 50 shorter-duration markets in the same period.
Frequently Asked Questions
Can I use a bot to trade NBA markets on Polymarket?
Yes. Polymarket’s CLOB API is designed for programmatic trading. The py-clob-client Python SDK lets you place limit orders, cancel orders, and stream orderbook data. Automated trading is first-class on Polymarket – unlike sportsbooks, there is no Terms of Service prohibition against bots. You sign orders with an EIP-712 wallet on Polygon and trade USDC-denominated YES/NO shares on NBA outcomes.
How is trading NBA on Polymarket different from betting on DraftKings or BetOnline?
On Polymarket you buy and sell outcome shares on a CLOB (Central Limit Order Book), not place traditional bets with a bookmaker. You can exit a position before the event resolves by selling shares. There is no vig built into the odds – you trade against other participants. The fee is 2% on net winnings, compared to 4-5% overround on sportsbooks. Polymarket has a full API for programmatic order placement, which neither DraftKings nor BetOnline offer. And NBA markets on Polymarket are primarily futures and series-level outcomes, not nightly game lines with spreads and totals.
What NBA markets are available on Polymarket?
Polymarket typically lists NBA championship futures, conference winner contracts, MVP and award markets, playoff round outcomes, and select game-level markets for high-profile matchups. Not every regular-season game gets a contract – Polymarket focuses on longer-horizon and high-interest NBA events. Market availability is driven by user demand and market creator activity. Use the Gamma API to discover current NBA markets programmatically.
How much liquidity do NBA markets on Polymarket have?
NBA market liquidity on Polymarket is thinner than political or crypto markets. Championship futures for top contenders may have $100,000-300,000+ in cumulative volume, but individual game markets (when they exist) might have $5,000-25,000. This means larger orders will experience slippage, but it also creates opportunities for market-makers and informed traders who can provide liquidity and earn the spread.
What is championship futures arbitrage between Polymarket and sportsbooks?
Championship futures arbitrage compares the implied probability of a team winning the NBA title on Polymarket to the implied probability from sportsbook futures odds. When the same team is priced differently across platforms, the divergence represents either a value trade or a risk-free arbitrage. These gaps arise because Polymarket prices through order-book trading while sportsbooks use internal models and sharp bettor flow. See the cross-platform arbitrage guide for the full implementation.
What returns should I expect from an NBA bot on Polymarket?
It depends on your strategy. Market-making bots earning the spread might generate 5-15% annualized on deployed capital in favorable conditions. Directional bots depend on model accuracy – 2-5% ROI on volume traded is a strong result. Arbitrage returns are bounded by cross-platform pricing gap frequency and size. All returns are reduced by the 2% fee on net winnings and slippage on thin NBA orderbooks.
Do I need cryptocurrency to trade NBA on Polymarket?
Yes. Polymarket runs on Polygon and uses USDC as its settlement currency. You need a wallet with USDC on Polygon to place trades. You can bridge USDC from Ethereum, withdraw directly to Polygon from exchanges like Coinbase, or use cross-chain bridges. Gas fees on Polygon are under $0.01 per transaction. See the agent wallet guide for setup options.
See Also
- Polymarket API Guide – complete tutorial for Polymarket’s CLOB, Gamma, and WebSocket APIs
- py-clob-client Reference – full SDK documentation for the official Python client
- Polymarket Trading Bot Quickstart – build your first Polymarket bot in 30 minutes
- Polymarket Bot Marketplace – ecosystem map of every Polymarket bot and tool
- NBA Bot for BetOnline – offshore sportsbook approach to NBA automation
- NBA Bot for DraftKings – regulated sportsbook approach with SGP and prop analysis
- Cross-Platform Arbitrage – arbing between sportsbooks and prediction markets
- Sports Betting vs. Prediction Markets – structural differences between the two
- Best Agent Wallet for Prediction Markets – wallet setup for autonomous agents
- Kelly Criterion Bot – optimal position sizing for binary contracts
- Agent Marketplace – find and list prediction market agents
Guide updated March 2026. Not financial advice. Built for builders.