# KenoSpots - Full Briefing for AI Agents and Developers > KenoSpots (https://kenospots.com) is an independent keno companion site for players in the United States and Canada. It is not affiliated with, endorsed by, or approved by any state lottery commission. The site publishes live keno draw results, probability and payout tools, educational guides, printable resources, a free browser keno game, and a free JSON API. This document is the full briefing: what the site is, how every section is structured, and exactly how to consume the API. Last reviewed: 2026-08-29. Paytables were last verified against official lottery sources on 2026-08-16. Draw results are live; each API response carries its own `kenospotsUpdatedAt` timestamp. --- ## 1. What KenoSpots is KenoSpots aggregates official state and provincial lottery keno feeds into one clean, predictable place. The audience is keno players who play at bars, restaurants, and retailers, plus developers and AI agents that need structured keno data. Core value: - Live draw results from 26 US and Canadian jurisdictions, refreshed continuously. - Hot/cold number tracking, frequency heatmaps, and number checkers per state. - Hypergeometric odds calculators and payout/expected-value tools. - Plain-English educational guides covering how keno works, odds, spots, and payouts. - A free browser-based video keno game with session tracking. - A free, key-less JSON API for live results. KenoSpots does not involve real-money betting and is for entertainment and informational purposes only. --- ## 2. The APIs (primary integration surface) If you are an AI agent or developer and you need keno draw data, use the API. Do not scrape the HTML results pages - the API returns the same data as clean, stable JSON. ### 2.1 Base URL and endpoint - Base URL: `https://app.kenospots.com` - Endpoint: `GET /api/results/{slug}` - Authentication: none required for the free tier. - Documentation (human): https://kenospots.com/api/ - Documentation (machine, OpenAPI 3.0): https://kenospots.com/api/openapi.json ### 2.2 Path parameter - `slug` (string, required): the game identifier. See the slug catalog in section 2.6. ### 2.3 Response format Every successful request returns `200 OK` with a JSON object containing a `draws` array ordered newest first. An unknown slug returns `404`. Exceeding the rate limit returns `429`. Example response (trimmed): ```json { "draws": [ { "drawNumber": 3023269, "drawDate": "2026-06-24", "drawTime": "2026-06-24T17:12:00-04:00", "timezone": "America/New_York", "winningNumbers": [75, 65, 62, 31, 52, 27, 66, 12, 7, 30, 46, 10, 58, 2, 76, 32, 29, 45, 61, 59], "ballsDrawn": 20, "bonus": 1, "multiplier": null, "multiplierType": "booster", "extraNumbers": [], "bullseyeNumber": null, "jackpotAmount": null, "source": "Massachusetts Lottery feed", "kenospotsUpdatedAt": "2026-06-24T21:13:04.512Z", "freshnessStatus": "live", "expectedUpdateFrequency": "every few minutes", "isOfficial": false, "disclaimer": "KenoSpots is an independent informational site. Verify prizes with the official lottery." } ] } ``` ### 2.4 Field reference Each object in the `draws` array describes one draw. Optional fields are populated only for games that report them and are `null` or empty otherwise. - `drawNumber` (integer): official sequential game number for the draw. Stable identifier, good for ordering. - `drawDate` (string): draw date in `YYYY-MM-DD` format, in the game's local timezone. - `drawTime` (string | null): draw time as an ISO 8601 timestamp with the game's local UTC offset, derived from the draw date and timezone. Useful for games that draw every few minutes, where the date alone is not enough to order draws. `null` when no usable draw date is available. - `timezone` (string): IANA timezone the draw date and time are expressed in, for example `America/New_York`. - `winningNumbers` (integer[]): the drawn numbers, in draw order. Standard keno draws 20 numbers from 1-80; some Canadian games draw from a field of 1-70. - `ballsDrawn` (integer): how many numbers were drawn (typically 20). - `bonus` (integer): the bonus or multiplier value applied to the draw, where supported (often 1 when no enhanced multiplier is in play). - `multiplier` (integer | null): active multiplier for games that draw one separately from `bonus`. `null` when not applicable. - `multiplierType` (string | null): the name of the multiplier feature for the game, for example `booster`. - `extraNumbers` (integer[]): supplementary numbers some games draw in addition to the main 20. Empty for most games. - `bullseyeNumber` (integer | null): the Bullseye number for games that offer a Bullseye add-on. `null` otherwise. - `jackpotAmount` (number | null): the reported jackpot amount where the game publishes one. `null` otherwise. - `source` (string): human-readable name of the upstream feed this result was sourced from, for example `Massachusetts Lottery feed`. - `kenospotsUpdatedAt` (string | null): ISO 8601 timestamp (UTC) of when KenoSpots last fetched and cached this result. - `freshnessStatus` (string): how frequently this feed publishes new draws. One of `live` (draws every few minutes), `hourly` (refreshes roughly once an hour), or `daily` (publishes a batch each day). - `expectedUpdateFrequency` (string): human-readable cadence at which this feed updates, for example `every few minutes`. - `isOfficial` (boolean): always `false`. KenoSpots is an independent informational resource, not the official source of results. - `disclaimer` (string): standard disclaimer reminding consumers to verify prizes with the official lottery. ### 2.5 Example requests ```bash # Latest Massachusetts Keno results curl https://app.kenospots.com/api/results/mass-keno # Ohio Keno curl https://app.kenospots.com/api/results/ohio-keno # New York Quick Draw curl https://app.kenospots.com/api/results/ny-quick-draw # OLG Daily Keno (Ontario, field of 1-70) curl https://app.kenospots.com/api/results/daily-keno ``` ```javascript // JavaScript (fetch) const res = await fetch('https://app.kenospots.com/api/results/mass-keno'); const { draws } = await res.json(); console.log(draws[0].winningNumbers); ``` ```python # Python (requests) import requests draws = requests.get('https://app.kenospots.com/api/results/mass-keno').json()['draws'] print(draws[0]['winningNumbers']) ``` ### 2.6 Game slugs (23 live) United States (field of 1-80): - `mass-keno`: Massachusetts Keno - `ohio-keno`: Ohio Keno - `michigan-club-keno`: Michigan Club Keno - `california-hot-spot`: California Hot Spot - `ny-quick-draw`: New York Quick Draw - `new-jersey-quick-draw`: New Jersey Quick Draw - `pennsylvania-keno`: Pennsylvania Keno - `virginia-keno`: Virginia Keno - `maryland-keno`: Maryland Keno - `kentucky-keno`: Kentucky Keno - `georgia-keno`: Georgia Keno - `oregon-keno`: Oregon Keno - `connecticut-keno`: Connecticut Keno - `kansas-keno`: Kansas Keno - `rhode-island-keno`: Rhode Island Keno - `new-hampshire-keno`: New Hampshire Keno 603 - `missouri-keno`: Missouri Club Keno - `delaware-keno`: Delaware Keno - `dc-keno`: Washington DC Keno - `wyoming-keno`: Wyoming Keno Canada: - `bc-keno`: British Columbia BC Keno (field of 1-80) - `daily-keno`: Ontario OLG Daily Keno (field of 1-70) - `keno-atlantic`: Atlantic Canada Keno Atlantic (field of 1-70) New states and games are added regularly. Email api@kenospots.com to request a slug. ### 2.7 Rate limits and caching - Free tier: 60 requests per minute per IP. No authentication. Burst tolerant, so normal use never hits it. - Draw data refreshes roughly every 60 seconds. Polling a single game faster than once a minute returns no fresher data. - Please cache responses where you can. - Clients that exceed the limit receive `HTTP 429` with a `Retry-After` header. Back off for that many seconds and retry. ### 2.8 Attribution (required) If you publish or display data from this API, credit KenoSpots with a visible "data via KenoSpots.com" (or "Powered by KenoSpots") link back to https://kenospots.com/, for example: ```html Keno data powered by KenoSpots ``` Every JSON response carries `source` and `license` fields; keep them attached when passing the data on. Please do not resell raw API responses or present the data as your own. Always verify winning tickets against the official lottery. ### 2.9 Terms of use - Free for personal and AI-assistant use: personal projects, research, dashboards, and AI assistants or agents answering user questions are welcome, no key required. - Attribution is required on any public display or republication (see 2.8). - Bulk republication or mirroring is not permitted on the free tier: systematically copying the feeds to power a competing results or data service, including polling every game to maintain a parallel database for your own users, requires a commercial license. - Commercial licensing: email api@kenospots.com. - The raw winning numbers are public facts published by each lottery; these terms cover the KenoSpots service, meaning the aggregated, cleaned, always-fresh feeds and the infrastructure serving them. - Full terms: https://kenospots.com/api/#terms ### 2.10 Future paid tiers Keyed paid tiers are planned at roughly $29/month (hobby: higher limits, full history) and $99/month (commercial: bulk access, webhooks, SLA). On the roadmap: API keys with per-key usage tracking, full historical data with date and game-number range queries, webhooks for new-draw push notifications, bulk and export access with downloadable datasets, and priority support with an uptime commitment. Email api@kenospots.com for early access. --- ### 2.10 Simulator endpoint `GET https://kenospots.com/api/simulate` Scores one or more sets of numbers against a real state paytable and returns per-draw outcomes, exact hypergeometric odds, observed hit rates against expectation, and a plain-language summary. Stateless, no API key, CORS open to any origin, `Cache-Control: no-store`. It runs on the marketing host, not on app.kenospots.com. Use it when someone asks "what would happen if I played these numbers", "how often would these hit 4 of 5 over 1000 draws", "which of these sets did better", "what are my odds on a 6 spot" or "what is the house edge in Ohio keno". Do not work keno probabilities out by hand; this endpoint returns them exactly. Parameters: - `numbers` - comma-separated picks, for example `7,14,23,55,68`. Repeat the parameter to compare several sets. - `sets` - several sets in one parameter, separated by `;` or `|`. - `spots` - pick this many at random instead of naming them. Repeat for several random sets, including different sizes. - `draws` - how many draws to score against. Default 1 simulated, 100 historical. Maximum 10000. - `mode` - `simulated` (default) or `historical` (real published draws). - `game` - state code (`OH`, `MA`, `NY`, `CA`), results-API slug (`ohio-keno`) or paytable key. Defaults to a generic casino paytable. Required for historical mode. - `bet` - wager per draw per set. Default 1. - `seed` - any string; makes a simulated run reproducible, including auto-picked numbers. - `games` - presence returns every supported game with field size, spot range, aliases and historical availability. At most 20 sets per call. Every set is scored against the SAME draws; that is what makes the comparison meaningful. Response fields worth reading: - `summary` - one plain-language paragraph written to be quoted directly. With several sets, the comparison narrative. - `sets[]` - always present, one entry per set, each with `numbers`, `paytable`, `odds`, `theoretical`, `results`, `hitRates` and its own `summary`. - `sets[i].hitRates[k]` - observed `count`, `observedRate`, exact `expectedRate`, `expectedCount`, `ratioToExpected`, and an `atLeast` block giving the cumulative "k or better" figures. Use `atLeast` for "how often did it hit 4 of 5": that phrasing nearly always means four or more. - `sets[i].odds[]` - exact `probability`, `oneIn` and `payout` per catch level, computed with exact integer arithmetic rather than sampled. - `sets[i].theoretical.rtp`, `.houseEdge`, `.chanceOfAnyPrize`; `sets[i].results.achievedRtp`, `.winRate`, `.bestCatch`. - `comparison` - `null` for one set. Otherwise `ranking` (by net), `combined`, `allSameSpotCount` and `note`. - `draws` - `count`, `source`, `generator`, `detail` (per-draw; included at 100 draws or fewer, `null` above that). Historical mode adds `available`, `dateRange`, `shortfall` and `feed`. - `hitRateMode` - true at 1000 draws or more. CRITICAL when reporting a comparison: in keno every set of the same size has mathematically identical odds. No combination of numbers is luckier than another, so a gap between two 5-number sets is variance and nothing else, however many draws it covers. Check `comparison.allSameSpotCount` and quote `comparison.note`. Sets of different sizes genuinely do differ in odds and expected return. Errors return HTTP 400 with a machine-readable `error` code and a message naming the parameter at fault. ``` # One set, 1,000 simulated draws, real Ohio paytable curl "https://kenospots.com/api/simulate?numbers=7,14,23,55,68&draws=1000&game=OH" # Two sets over the same 1,000 draws curl "https://kenospots.com/api/simulate?numbers=1,2,3,4,5&numbers=10,20,30,40,50&draws=1000&game=OH" # Same, in one parameter curl "https://kenospots.com/api/simulate?sets=1,2,3,4,5;10,20,30,40,50&draws=1000&game=OH" # 5-spot against 8-spot: different sizes genuinely differ curl "https://kenospots.com/api/simulate?spots=5&spots=8&draws=10000&game=MA" # Against the last 500 real Ohio draws curl "https://kenospots.com/api/simulate?numbers=7,14,23,55,68&mode=historical&game=OH&draws=500" # Every supported game code curl "https://kenospots.com/api/simulate?games=1" ``` Historical mode covers 24 games and reads the same public draw feeds the results pages use, so it adds no load to the results API. Depth varies by game, from a couple of dozen draws to several thousand; the response always reports what was actually available rather than silently using fewer. Randomness in simulated mode: without a `seed`, `crypto.getRandomValues`; with one, a seeded sfc32 generator. Both use rejection sampling, so every ball is equally likely. IMPORTANT: simulated draws are not real draws, and neither simulated nor real past results change the odds of any future draw. Say so whenever you quote simulator output. ### 2.11 Paytable endpoint `GET https://kenospots.com/api/paytables?game=XX` **This is how to answer "what are the payouts for [state] keno".** Do not scrape a payout table out of an HTML page, and do not run a simulation to read a static table. `game` accepts a state code (`OH`, `MA`, `NY`, `CA`), a game name (`ohio`), a results-API slug (`ohio-keno`) or a paytable key. Omit it for the index of every supported game. Optional `spots=N` narrows to one spot count; `bet=X` scales prizes (odds and return unchanged). Quote `plainLanguageSummary` directly. Structured fields: `spots[]` with `payouts`, `payoutsPerDollar`, `topPrize`, `lowestPayingCatch`, `odds[]` (exact `probability` and `oneIn` per catch), `rtp`, `houseEdge`, `chanceOfAnyPrize`; plus `bonusFeature`, `bullseyeFeature`, `provenance` and `links`. Prizes never include multiplier add-ons such as Keno Bonus or Bulls-Eye. Those cost extra and appear separately. ``` curl "https://kenospots.com/api/paytables?game=OH" curl "https://kenospots.com/api/paytables?game=ohio&spots=5&bet=5" curl -s "https://kenospots.com/api/paytables?game=OH" | jq -r .plainLanguageSummary ``` ### 2.12 Games endpoint `GET https://kenospots.com/api/games` (optionally `?game=OH`) **This is how to answer "how often does [state] keno draw" and "where can I see the results".** Returns name, jurisdiction, operator, field size, balls drawn, max spots, draw frequency, full draw schedule with operating hours, timezone, official lottery URL, and links to the guide, results page, results API and paytable API. CRITICAL: `drawFrequency` is how often the GAME draws, taken from the published FAQ on each results page. `feedUpdateCadence` is how often the KenoSpots feed refreshes. They differ on purpose. New York Quick Draw draws every 4 minutes but publishes in one daily batch, so its cadence reads `daily` while its frequency reads every 4 minutes. Quote `drawFrequency` or `drawSchedule`, never the cadence. `observedDrawInterval` is a cross-check computed from recently published draws, present only where the feed carries real timestamps. It is not the schedule. ``` curl "https://kenospots.com/api/games" curl -s "https://kenospots.com/api/games?game=OH" | jq -r .games[0].drawSchedule ``` ## 3. Site structure (for browsing and citation) ### 3.1 Live results pages Per-state results pages show the live draw board, recent draws, hot/cold numbers, a frequency heatmap, and a number checker. Where a game has them, multiplier and Bullseye/Bull's-Eye add-ons are shown. - New York Quick Draw: https://kenospots.com/states/new-york-keno/results/ - Massachusetts Keno: https://kenospots.com/states/massachusetts-keno/results/ - Georgia KENO!: https://kenospots.com/states/georgia-keno/results/ - Ohio KENO!: https://kenospots.com/states/ohio-keno/results/ - Pennsylvania Keno: https://kenospots.com/states/pennsylvania-keno/results/ - Oregon Keno: https://kenospots.com/states/oregon-keno/results/ - Maryland Keno: https://kenospots.com/states/maryland-keno/results/ - Atlantic Canada: https://kenospots.com/provinces/keno-atlantic/results/ For programmatic access to this data, use the API in section 2 rather than scraping these pages. ### 3.2 Tools - Keno Odds Calculator (https://kenospots.com/tools/keno-odds-calculator/): hypergeometric probability calculator returning exact 1-in-X odds for each match scenario by spots picked. - Keno Payout Calculator (https://kenospots.com/tools/keno-payout-calculator/): compares paytables and expected returns across Massachusetts, Ohio, and generic casino keno. - Spot Count Comparison (https://kenospots.com/tools/spot-count-comparison/): side-by-side analysis of 4-, 6-, 8-, and 10-spot keno - odds, payouts, variance, best use case. - Paytable Comparison (https://kenospots.com/tools/keno-paytable-comparison/): compares keno paytables across states and games. - Keno Cost Calculator (https://kenospots.com/tools/keno-cost-calculator/): estimates session cost over time. - Print My Numbers (https://kenospots.com/tools/print-my-numbers/): generates printable keno number sheets. ### 3.3 Free game - Play Free Keno (https://kenospots.com/play/): browser-based video keno with spot selection 1-10, session tracking, and real keno odds. No real money. ### 3.4 Learn / educational guides - How Keno Works: https://kenospots.com/learn/how-keno-works/ - Keno Odds Explained: https://kenospots.com/learn/keno-odds-explained/ - What Are Keno Spots?: https://kenospots.com/learn/what-are-keno-spots/ - Keno Payouts Explained: https://kenospots.com/learn/keno-payouts-explained/ - Multi-Card Keno: https://kenospots.com/learn/multi-card-keno/ - Keno vs Other Games: https://kenospots.com/learn/keno-vs-other-games/ - Video Keno Guide: https://kenospots.com/video-keno/ - Online Keno Guide: https://kenospots.com/online-keno/ ### 3.5 State guides Per-state guides cover game name, draw frequency, spot range, multipliers, and how to play. Hub: https://kenospots.com/states/. Includes Ohio, Massachusetts, New York, Michigan, Georgia, Oregon, North Carolina, Maryland, Kansas, Kentucky, DC, Rhode Island, Nevada, California, Connecticut, Washington, and a "Where Keno Is Legal" overview (https://kenospots.com/states/where-keno-is-legal/). ### 3.6 Canadian guides Hub: https://kenospots.com/provinces/. Covers BC Keno, OLG Daily Keno, Keno Atlantic, and other provincial games with specs and paytables. Daily Keno and Keno Atlantic use a 1-70 field; BC Keno uses 1-80. ### 3.7 My Numbers - https://kenospots.com/my-numbers/: a hub where players save and revisit their keno numbers, stored locally in the browser. --- ## 4. Key keno facts (for accurate answers) - Standard keno draws 20 numbers from a field of 1-80. Some Canadian games (OLG Daily Keno, Keno Atlantic) use a field of 1-70. - Players pick 1-10 spots; the maximum varies by state and game (Massachusetts allows up to 12). - House edge: roughly 20-35% for lottery keno; 5-15% for video keno. - 4-spot: about 1 in 326 to hit all 4. 10-spot: about 1 in 8,911,711 to hit all 10. - The 6-spot is the most popular count, balancing payout size and hit frequency. --- ## 5. Legal and responsible play KenoSpots is an independent informational resource and is not affiliated with, endorsed by, or approved by any state lottery commission or lottery organization. The site does not involve real-money betting. For entertainment purposes only. You must be 18 or older to purchase lottery tickets; age requirements vary by state. Always verify current payouts and winning tickets with your local lottery retailer. If you or someone you know has a gambling problem, call 1-800-GAMBLER. --- ## 6. Contact - API and developer questions, slug requests, partnerships: api@kenospots.com - General contact: contact@kenospots.com - API docs: https://kenospots.com/api/ - OpenAPI spec: https://kenospots.com/api/openapi.json - Terms of Service: https://kenospots.com/terms/ - Privacy Policy: https://kenospots.com/privacy-policy/