Card Player APIcardplayer.com ↗
Access Card Player data via API: poker odds calculator, player profiles, tournament schedules, hand matchups, and news articles across 11 endpoints.
What is the Card Player API?
The Card Player API covers 11 endpoints exposing poker odds calculations, player leaderboard data, tournament listings, hand matchup analyses, and news articles from cardplayer.com. The calculate_odds endpoint accepts seat configurations with specific card strings and returns win/lose/tie percentages plus expected value for each seat across six game types including Texas Hold'em, Omaha, and Razz.
curl -X GET 'https://api.parse.bot/scraper/d34dab5c-57a6-46d7-aea9-f8330c24ac01/calculate_odds?board=%5B%227h%22%2C%222d%22%2C%22Tc%22%5D&seats=%5B%7B%22hand%22%3A+%5B%22As%22%2C+%22Ac%22%5D%2C+%22position%22%3A+1%7D%2C+%7B%22hand%22%3A+%5B%22Ks%22%2C+%22Kc%22%5D%2C+%22position%22%3A+2%7D%5D&game_type=texas_holdem&dead_cards=%5B%223s%22%5D' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace cardplayer-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Card Player API — poker odds, news, players, tournaments, and hand matchups."""
from parse_apis.Card_Player_API import CardPlayer, GameType, ContentNotFound, Calculator
client = CardPlayer()
# Calculate Texas Hold'em odds: pocket aces vs pocket kings
holdem = client.calculator(GameType.TEXAS_HOLDEM)
for result in holdem.calculate(seats='[{"hand": ["As", "Ac"], "position": 1}, {"hand": ["Ks", "Kc"], "position": 2}]', limit=5):
print(result.position, result.hand, f"Win: {result.win_pct}%", f"EV: {result.ev}")
# List available calculators
for calc in client.calculators.list(limit=6):
print(calc.name, calc.slug, calc.url)
# Browse recent poker news articles
for article in client.articles.list(limit=3):
print(article.title, article.url, article.id)
# Search for WSOP content and drill into first result
wsop_hit = client.articles.search(query="WSOP", limit=1).first()
if wsop_hit:
print(wsop_hit.title, wsop_hit.type, wsop_hit.subtype)
# List players by name
player = client.players.list(player_name="Negreanu", limit=1).first()
if player:
print(player.name, player.earnings, player.location)
# Typed error handling — catch not-found on a bad article fetch
try:
client.articles.search(query="zzz_nonexistent_xyz_999", limit=1).first()
except ContentNotFound as exc:
print(f"Content not found: {exc}")
# List upcoming tournaments
for tourney in client.tournaments.list(limit=3):
print(tourney.title, tourney.date, tourney.link)
# Get odds and outs reference tables
for table in client.odds_tables.list(limit=3):
print(table.header, len(table.rows))
print("exercised: calculator.calculate / calculators.list / articles.list / articles.search / players.list / tournaments.list / odds_tables.list")
Calculate poker odds for given seat hands using the Card Player odds calculator. Accepts seat configurations with hands and optional board/dead cards. Returns win/lose/tie percentages and expected value for each seat. Requires at least two seats with valid card hands.
| Param | Type | Description |
|---|---|---|
| board | string | JSON-encoded array of board card strings. Example: ["7s", "8s", "9s"] |
| seatsrequired | string | JSON-encoded array of seat objects. Each seat has 'hand' (array of card strings like 'As', 'Kc') and 'position' (integer). Example: [{"hand": ["As", "Ac"], "position": 1}, {"hand": ["Ks", "Kc"], "position": 2}] |
| game_type | string | Poker game variant for odds calculation. |
| dead_cards | string | JSON-encoded array of dead card strings removed from play. Example: ["2h", "3h"] |
{
"type": "object",
"fields": {
"seats": "array of seat result objects with position, hand, win, win_pct, lose, lose_pct, tie, tie_pct, and ev fields"
},
"sample": {
"data": {
"seats": [
{
"ev": "0.83",
"tie": "9,308.00",
"win": "1,410,336.00",
"hand": [
"As",
"Ac"
],
"lose": "292,660.00",
"tie_pct": "0.54",
"win_pct": "82.36",
"lose_pct": "17.09",
"position": "1"
},
{
"ev": "0.17",
"tie": "9,308.00",
"win": "292,660.00",
"hand": [
"Ks",
"Kc"
],
"lose": "1,410,336.00",
"tie_pct": "0.54",
"win_pct": "17.09",
"lose_pct": "82.36",
"position": "2"
}
]
},
"status": "success"
}
}About the Card Player API
Odds Calculator and Game Coverage
The calculate_odds endpoint accepts a seats parameter — a JSON-encoded array of seat objects each containing a hand array of card strings (e.g. As, Kc) and a position. Optional board, dead_cards, and game_type parameters let you model specific board runouts and eliminate cards from the deck. Supported game types are texas_holdem, omaha, omaha_8_hilo, seven_card_stud, razz, and deuce_to_seven. Each seat result includes win, win_pct, lose, lose_pct, tie, tie_pct, and ev fields. Use get_calculator_info to retrieve valid slug values for the game_type parameter.
Player Data and Tournament Schedules
get_players returns leaderboard entries with name, url, location, earnings, and last_cash fields, and accepts an optional player_name filter for targeted lookups. Pass the url field from those results into get_player_profile to retrieve a full profile including summary (career stats such as recorded earnings and tournament wins), recent_cashes, and top_cashes — each cash entry carrying date, event, place, and winnings. get_tournaments returns paginated tournament series with id, title, slug, date, link, and status fields.
News, Hand Matchups, and Site Search
get_poker_news returns paginated article summaries with id, title, url, type, and subtype. Feed an article_id from those results into get_news_article to get the full rendered content, excerpt, publication date, author ID, and slug. get_hand_matchups follows the same pagination pattern and returns post objects with yoast_head_json SEO metadata; get_hand_matchup_detail returns the full rendered content for a single matchup. search_site accepts a query string and returns matching results across articles, players, pages, and other content types with total_items and total_pages in the response.
Reference Tables
get_odds_and_outs returns static poker reference data organized as an array of table objects, each with a header array of column names and a rows array of string arrays. Tables cover starting hand probabilities, drawing odds by number of outs, overcard probabilities, and pre-flop matchup statistics — useful for building educational poker tools without needing to hardcode the reference data yourself.
The Card Player API is a managed, monitored endpoint for cardplayer.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when cardplayer.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official cardplayer.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a poker equity calculator that computes win/lose/tie percentages for multi-way Texas Hold'em or Omaha hands using
calculate_odds. - Track professional poker player earnings and recent tournament results using
get_player_profilecareer stats and cash history. - Aggregate and display the latest poker news headlines in a content feed by paginating through
get_poker_newsresults. - Display a tournament calendar in a poker app by fetching series names, dates, and links from
get_tournaments. - Embed poker odds and outs reference tables in a training application using the structured data from
get_odds_and_outs. - Enable full-text search across cardplayer.com content — players, articles, pages — via the
search_siteendpoint with aqueryparameter. - Analyze hand matchup content at scale by iterating
get_hand_matchupsand fetching full post details withget_hand_matchup_detail.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Card Player have an official developer API?+
What card string format does `calculate_odds` expect?+
As (Ace of spades), Kc (King of clubs), or 7h (Seven of hearts). The seats, board, and dead_cards parameters all accept JSON-encoded arrays of these strings. The game_type slug values can be confirmed by calling get_calculator_info first.Does `get_poker_news` always return a reliable `total_items` count?+
total_items may be 0 when the underlying search omits pagination headers. Use total_pages alongside the actual count of returned articles to determine whether additional pages exist, rather than relying solely on total_items.Does the API cover live tournament results or chip counts during an event?+
get_tournaments and player cash history via get_player_profile, but live chip counts, hand-by-hand updates, or in-progress event data are not exposed. You can fork this API on Parse and revise it to add an endpoint targeting live event coverage.Are individual player social media profiles or contact details included in `get_player_profile`?+
name, summary (biographical fields like Nickname, Hometown, Country of Origin, Birthdate, Recorded Earnings, Tournament Wins), and cash history arrays. Social handles and contact details are not part of the response. You can fork this API on Parse and revise it to add those fields if they appear on individual player pages.