> ## Documentation Index > Fetch the complete documentation index at: https://docs.0xinsider.com/llms.txt > Use this file to discover all available pages before exploring further. # Get Pick of the Day > One sourced sharp-money call a day (Insider-tier). Returns the published pick for the CURRENT product day: the backed side, the pre-game odds and $100 return, the proven smart-money holders on that side, the grade, and the thesis. The price is snapshotted before kickoff so it does not drift. It never serves a prior day's finished pick as today's, so an automated consumer never acts on a stale, already-settled game (a prior pick stays available through the archive endpoint). When no pick is published for the current product day it returns 404 with error.code="not_found" and error.reason="pick_not_released" -- branch on the reason, because error.code is a frozen contract and stays "not_found". That 404 is a schedule, not an outage: each selected pick normally releases one hour before its provider kickoff, within the 11:00-19:00 UTC operating window; a skipped day has no release. DO NOT POLL. error.retry_at (RFC3339, always in the future) and Retry-After give the recommended next attempt: an exact floor before a scheduled release, or a bounded cadence while the selector is hunting. Schedule one request rather than sleeping a worker thread. One sourced sharp-money call a day, promoted to the API. This is an Insider-tier endpoint: your API key already proves the subscription, so the response is always the full pick (the web teaser is a product-UI concept, not an API one). The pick returns the backed side, the pre-game odds and the return on a \$100 stake, the proven smart-money holders on that side, the grade and category edge, and the thesis behind it. * `backed_price` and `return_per_100` are a snapshot frozen before kickoff, so the value does not drift between calls. * `sharp_pct`, `market_pct`, and `consensus_edge_pct` are the WHY breakdown: sharp-money conviction versus the market-implied price. These are conviction signals, not expected-value or guaranteed-edge claims. * `outcome` is `pending` until the market resolves, then `win`, `loss`, or `void`. * `sports_context` carries provider-owned team crests, league branding, and live score for team-sports picks; it is omitted otherwise. * Returns `404` when no pick is published right now. ```bash theme={null} curl -H "Authorization: Bearer $OXINSIDER_API_KEY" \ "https://api.0xinsider.com/api/v1/pick-of-the-day" ``` The response is side-effect-free and ETag-cacheable. Send the previous `ETag` back via `If-None-Match` to get a `304 Not Modified` when the pick is unchanged. For the full track record and rolling hit rate, see [Get Pick of the Day track record](/api-reference/endpoint/get-pick-of-the-day-archive). ## OpenAPI ````yaml GET /api/v1/pick-of-the-day openapi: 3.1.0 info: title: 0xinsider API description: >- Find your edge on Polymarket and Kalshi. Every wallet graded, every trade scored, every outlier flagged. API exposes trader grades, whale trades, smart money signals, and insider detection for AI agents, trading bots, and research tools. Normal API requests use a 30-second server timeout that returns HTTP 408 Request Timeout with an empty body when exceeded. Public REST /api/v1/* endpoints, excluding /api/v1/mcp, use Bearer-token based non-credentialed browser CORS: any Origin may call with Authorization, Content-Type, If-None-Match, Idempotency-Key, and Mcp-Session-Id request headers. Remote MCP at /api/v1/mcp is non-credentialed, but still validates Origin against the 0xinsider/localhost allowlist per MCP Streamable HTTP DNS-rebinding guidance. Successful browser CORS preflight responses advertise Access-Control-Max-Age: 86400. Browser JavaScript may read X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After, ETag, X-Request-Id, X-Request-Cost, X-Batch-RateLimit-Limit, X-Batch-RateLimit-Remaining, X-Batch-RateLimit-Reset, Mcp-Session-Id, and X-Mcp-Error-Code response headers. Credentialed first-party routes such as /api/keys, /api/billing, and auth endpoints remain restricted to configured 0xinsider origins. version: 1.0.0 contact: name: 0xinsider email: support@0xinsider.com url: https://0xinsider.com servers: - url: https://api.0xinsider.com description: >- Production (live data). Authenticate with a live key (oxi_sk_live_...); requires an active Insider subscription. security: - bearerAuth: [] tags: - name: Traders description: Trader intelligence, batch lookups, timelines, and export readiness. - name: Positions description: Current prediction-market position snapshots from backend-owned mirrors. - name: Large Positions description: Largest current open positions from graded traders (Polymarket-only). - name: Whale Trades description: Recent and historical large trade intelligence. - name: Leaderboard description: Ranked trader discovery and category/strategy leaderboards. - name: Pick of the Day description: >- One sourced sharp-money call a day: the side proven smart money is backing, with pre-game odds, the proven holders, and the track record. - name: Markets description: Market search, discovery, snapshots, and smart-score flow. - name: Insider Radar description: Suspicious trading pattern detection. - name: Events description: Durable public event replay streams. - name: Streaming description: Resumable real-time Server-Sent Events stream of live feed envelopes. - name: Webhooks description: Signed builder webhook destinations and delivery controls. - name: Usage description: Developer API budget and usage introspection. - name: System description: Health and operational status checks. - name: MCP description: Remote Model Context Protocol transport. - name: Reports description: Daily, weekly, monthly, and trader export report snapshots. paths: /api/v1/pick-of-the-day: get: tags: - Pick of the Day summary: Get today's Pick of the Day description: >- One sourced sharp-money call a day (Insider-tier). Returns the published pick for the CURRENT product day: the backed side, the pre-game odds and $100 return, the proven smart-money holders on that side, the grade, and the thesis. The price is snapshotted before kickoff so it does not drift. It never serves a prior day's finished pick as today's, so an automated consumer never acts on a stale, already-settled game (a prior pick stays available through the archive endpoint). When no pick is published for the current product day it returns 404 with error.code="not_found" and error.reason="pick_not_released" -- branch on the reason, because error.code is a frozen contract and stays "not_found". That 404 is a schedule, not an outage: each selected pick normally releases one hour before its provider kickoff, within the 11:00-19:00 UTC operating window; a skipped day has no release. DO NOT POLL. error.retry_at (RFC3339, always in the future) and Retry-After give the recommended next attempt: an exact floor before a scheduled release, or a bounded cadence while the selector is hunting. Schedule one request rather than sleeping a worker thread. operationId: getPickOfTheDay parameters: - name: If-None-Match in: header required: false description: >- Conditional GET validator from a previous ETag. Matching values return 304 Not Modified with an empty body. schema: type: string responses: '200': description: Today's Pick of the Day headers: ETag: description: >- Stable validator for the current Pick of the Day payload. Re-send it via If-None-Match for conditional GETs. schema: type: string X-RateLimit-Limit: $ref: '#/components/headers/X-RateLimit-Limit' X-RateLimit-Remaining: $ref: '#/components/headers/X-RateLimit-Remaining' X-RateLimit-Reset: $ref: '#/components/headers/X-RateLimit-Reset' X-Request-Id: $ref: '#/components/headers/X-Request-Id' content: application/json: schema: type: object required: - object - data - meta properties: object: type: string const: pick_of_the_day data: $ref: '#/components/schemas/PickOfTheDay' meta: $ref: '#/components/schemas/ResponseMeta' examples: success: summary: Successful response value: object: pick_of_the_day data: state: full pick_date: '2026-06-23' matchup: Portugal vs. Uzbekistan category: Soccer platform: polymarket release_at: '2026-06-23T17:00:00Z' is_locked: false outcome: pending pick_outcome_label: Portugal position: Portugal to win side_summary: Smart money is backing Portugal smart_wallet_count: 7 top_grade: A smart_usd: 48250 backed_price: 0.62 return_per_100: 161.29 sharp_pct: 0.9 market_pct: 0.62 consensus_edge_pct: 0.28 directional_confidence: 0.82 one_way_holder_count: 3 hedged_holder_count: 1 one_way_graded_usd: 820 total_graded_usd: 1000 traders: 7 backed_sharp_usd: 312500 holders: - address: '0x0000000000000000000000000000000000000000' name: swisstony grade: A shares: 12500 holder_count: 7 editorial_note: null thesis: >- Graded soccer specialists are stacked on Portugal at a price the market has not fully repriced. market_url: https://0xinsider.com/market/portugal-vs-uzbekistan event_slug: portugal-vs-uzbekistan sports_context: league_name: FIFA World Cup league_logo: https://polymarket.com/leagues/fifa-world-cup.png yes_team: label: Portugal short_label: POR full_name: Portugal national football team provider_id: 1421 logo: https://polymarket.com/teams/portugal.png color: '#C8102E' record: null score: null no_team: label: Uzbekistan short_label: UZB full_name: Uzbekistan national football team provider_id: 1738 logo: https://polymarket.com/teams/uzbekistan.png color: '#1EB53A' record: null score: null game_id: 884213 event_matchup: false matchup_title: Portugal – Uzbekistan disclaimer: >- Not financial advice. Prediction markets carry risk; do your own research. meta: request_id: req_example cached: false cost: 1 '304': description: >- Not Modified. Returned when If-None-Match matches the current Pick of the Day payload. headers: ETag: description: Validator for the unchanged Pick of the Day payload. schema: type: string '401': $ref: '#/components/responses/Unauthorized' '402': $ref: '#/components/responses/SubscriptionRequired' '403': $ref: '#/components/responses/Forbidden' '404': $ref: '#/components/responses/PickNotReleased' '408': $ref: '#/components/responses/RequestTimeout' '423': $ref: '#/components/responses/Locked' '429': $ref: '#/components/responses/RateLimited' '503': $ref: '#/components/responses/RateLimitUnavailable' x-codeSamples: - lang: curl label: cURL source: |- curl -sS \ -H 'Authorization: Bearer $OXI_SK' \ 'https://api.0xinsider.com/api/v1/pick-of-the-day' components: headers: X-RateLimit-Limit: description: Authenticated V1 per-user request limit for the current sliding window. schema: type: integer example: 100 X-RateLimit-Remaining: description: >- Authenticated V1 requests remaining in the current sliding window after this response. schema: type: integer example: 84 X-RateLimit-Reset: description: Unix timestamp when the authenticated V1 request window resets. schema: type: integer example: 1710772860 X-Request-Id: description: Server-generated request identifier for support and tracing. schema: type: string example: req_550e8400 schemas: PickOfTheDay: type: object required: - state - pick_date - matchup - category - platform - release_at - is_locked - outcome - pick_outcome_label - position - side_summary - smart_wallet_count - thesis - disclaimer properties: state: type: string enum: - full description: Always 'full' for an authenticated Insider key. pick_date: type: string format: date description: The pick's local publication date (YYYY-MM-DD). matchup: type: string description: Human-readable matchup (e.g. "Portugal vs. Uzbekistan"). category: type: string description: Market category (e.g. "Soccer"). platform: type: string description: Provider platform (e.g. "polymarket"). release_at: type: string format: date-time description: >- The pick's stored release instant. Normally the current provider kickoff minus one hour; an operator may override it. The actual publish instant can trail it because of worker or claim delay. is_locked: type: boolean description: >- True only before the pick's stored release instant (a pre-release embargo flag); effectively always false on a served, already-published pick. To detect that the backed game has kicked off, use `game_started`. game_started: type: boolean description: >- True once the backed game's kickoff has passed (kickoff <= now). When true the snapshotted pre-game price is no longer actionable. Absent for a legacy pick with no stored kickoff (treat as not-started). outcome: type: string enum: - pending - win - loss - void description: >- Settlement outcome of the backed side; 'pending' until the market resolves. outcome_display: type: string description: >- Pre-formatted SETTLEMENT STATUS for display: "Win" / "Loss" / "Void" / "Pending" -- the outcome enum above as a label. Convenience only; outcome is the source value. NOTE: this is the win/loss STATUS, not the backed side. The backed side is pick_outcome_label ("Belgium (-2.5)") -- a different field answering a different question. pick_outcome_label: type: string description: >- The backed side phrased as a bet: a team for a moneyline (e.g. "Portugal"), the handicap line for a spread (e.g. "Belgium (-2.5)"), or "{team} to advance" for a knockout advancement market (e.g. "Spain to advance"). token_id: type: string nullable: true description: >- The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the backed outcome; null when unavailable (e.g. Kalshi markets, unsynced markets). position: type: string description: The backed side phrased as a bet (e.g. "Portugal to win"). side_summary: type: string description: One-line summary of which side smart money is backing. smart_wallet_count: type: integer description: Number of proven smart-money wallets on the backed side. top_grade: type: string nullable: true description: >- Highest trader grade among the backed-side holders (S, A, B, C, D, F). category_edge_pct: type: number nullable: true description: >- Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: category win-rate edge as a fraction (the backed-side cohort's win rate in this category minus the non-market-maker category baseline, e.g. 0.09 = +9 points), paired with category_edge_sample. category_edge_sample: type: integer nullable: true description: >- Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: pooled count of resolved markets behind category_edge_pct (the headline's n). smart_usd: type: number nullable: true description: Recency-weighted graded-flow magnitude in USD; omitted when <= 0. backed_price: type: number nullable: true description: Pre-game snapshot probability (0..1) for the backed side. odds_display: type: string nullable: true description: >- Pre-formatted backed_price as cents-on-the-dollar odds, to ONE decimal: "62.0c" / "99.9c". Never rounded to a whole cent -- a 99.9c favorite is not a 100c certainty. Convenience only; backed_price is the source value. Omitted when backed_price is. return_per_100: type: number nullable: true description: >- Gross return on a $100 stake at the snapshotted price (100 / backed_price). payout_display: type: string nullable: true description: >- Pre-formatted return_per_100 as USD with cents and thousands separators: "$161.29" / "$1,250.00". The GROSS return (the $100 stake included), so it carries no sign. Convenience only; return_per_100 is the source value. Omitted when return_per_100 is. profit_display: type: string nullable: true description: >- Pre-formatted PROFIT on the $100 stake -- return_per_100 minus the 100 stake, i.e. the payout net of what you put in -- as a signed USD string: "+$61.29". Distinct from payout_display, which is gross. Omitted when return_per_100 is. sharp_pct: type: number nullable: true description: >- Backed-side smart-money dollar consensus as a fraction 0..1: the share of the sharp dollars on the backed side. A conviction signal, NOT a probability or expected-value claim. Frozen at generation. market_pct: type: number nullable: true description: >- Market-implied probability of the backed side as a fraction 0..1 (equals backed_price), re-exposed alongside sharp_pct for the WHY breakdown. consensus_edge_pct: type: number nullable: true description: >- Consensus edge = sharp_pct - market_pct, the conviction-vs-price gap (how much more of the smart money sits on this side than the price implies). This is NOT an expected-value or guaranteed edge. Null when either input is null. directional_confidence: type: number nullable: true description: >- Team-directional commitment read at selection time: the fraction (0..1) of the backed side's graded smart-money DOLLARS held by wallets that are genuinely one-way on this game, rather than hedged across its markets. A high value means the graded pile is really committed to this side; a low one means much of it is hedged or unreadable. Omitted when the read was not computed (a pick selected before the field existed, an ungroupable game, or an empty graded pile) -- which is NOT the same as 0.0, a computed reading that nothing was confidently one-way. one_way_holder_count: type: integer nullable: true description: Graded backed-side holders read as one-way-committed on this game. hedged_holder_count: type: integer nullable: true description: Graded backed-side holders read as HEDGED across the game's markets. one_way_graded_usd: type: number nullable: true description: >- The one-way holders' share of the backed-side graded dollars (the confidence's numerator). total_graded_usd: type: number nullable: true description: >- Backed-side graded dollars the confidence is measured against (its denominator). traders: type: integer nullable: true description: >- Count of proven smart-money wallets on the backed side (equals smart_wallet_count). backed_sharp_usd: type: number nullable: true description: >- Raw backed-side smart-money USD frozen at generation (the 'Sharp $'), NOT the recency-weighted smart_usd which decays. holders: type: array nullable: true description: Proven smart-money holders on the backed side. items: $ref: '#/components/schemas/PickHolder' holder_count: type: integer nullable: true description: >- True total of proven holders on the backed side (may exceed the holders array length). editorial_note: type: string nullable: true description: Optional editorial note attached to the pick. thesis: type: string description: The reasoning behind the pick. market_url: type: string nullable: true description: Canonical web market URL. event_slug: type: string nullable: true description: >- The canonical /event game-page slug (one neutral page per game), null when the game has no neutral event page. sports_context: allOf: - $ref: '#/components/schemas/PickSportsContext' nullable: true description: >- Provider-first sports context for the pick's market (team logos, league branding, live score). Full-state only; omitted when the pick is not a team-sports market. disclaimer: type: string description: Risk disclaimer shown with every pick. ResponseMeta: type: object required: - request_id - cached - cost properties: request_id: type: string description: Unique request ID (req_ prefix). cached: type: boolean cache_age_s: type: integer nullable: true description: Cache age in seconds, null if not cached. cost: type: integer description: >- Advisory request weight (relative compute cost). 1 for simple reads; higher for heavier endpoints. Not a credit/price. directional_source: type: string enum: - live - degraded description: >- Which path produced the team-directional read on this response. Only present on endpoints that compute one (today: GET /api/v1/sports-edge-signals). "live" means the read RAN. "degraded" means it FAILED, so nothing was measured and the ranking fell back to raw conviction. The flag describes the READ, not its consequence: a read that ran and found nothing groupable also leaves the directional fields null, and that is honestly "live" -- the per-signal nulls already say "nothing to enrich here", so this snapshot-level flag carries only what they cannot, namely whether the read ran at all. A degraded response is cached on the shorter degraded TTL so it self-heals. Reported SEPARATELY from ranking_source because the two degradations are independent -- a smart-money DB miss weakens the ranking DATA, a directional failure removes a ranking WEIGHT -- and a consumer down-weighting a degraded response needs to know which input it lost. Omitted on endpoints that compute no directional read. ranking_source: type: string enum: - live - db_only description: >- Which ranking-data path produced this response. Only present on endpoints that can degrade a ranking (today: GET /api/v1/sports-edge-signals). "live" is the normal path (the current holder pile from the provider batch); "db_only" is the degraded fallback (a truthful but weaker trader_markets ranking) served when the live sharp-money ranking batch is unavailable (a smart-money DB read failure, not a Polymarket outage) and cached on a shorter TTL, so a consumer can down-weight or skip it. Omitted on endpoints that never degrade. PickHolder: type: object required: - address - shares properties: address: type: string name: type: string nullable: true grade: type: string nullable: true description: All-time trader grade (S, A, B, C, D, F). shares: type: number PickSportsContext: type: object required: - event_matchup description: >- Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Team logos and league logo are provider-owned (Polymarket /teams crests for clubs, country flags for national teams and tennis players); no local derivation. properties: league_name: type: string nullable: true description: League or competition display name (e.g. "Premier League"). league_logo: type: string nullable: true description: League logo URL (provider-owned). yes_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' nullable: true description: >- The team mapped to the market's YES outcome, or the parent-event home/first team when event_matchup is true. no_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' nullable: true description: >- The team mapped to the market's NO outcome, or the parent-event away/second team when event_matchup is true. game_id: type: integer nullable: true description: >- Provider game identifier (Polymarket Gamma gameId); omitted when null. event_matchup: type: boolean description: >- Always present. True when the two teams are the parent-event match identity for a teamless binary leg (e.g. a draw, totals, or prop market), not the market's own outcomes. event_subject_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' nullable: true description: >- Present only alongside event_matchup: the event team the binary leg is about (provider group_item_title matched to a matchup team, e.g. Belgium for "Will Belgium win?"), i.e. the winner on a Yes resolution. Omitted for teamless legs (draw, totals, prop). matchup_title: type: string nullable: true description: >- The two teams as a single whole-game label, joined " – " (en-dash) in provider display order (e.g. "Portugal – Uzbekistan"). Composed server-side from the provider team names (no title/slug parsing). Present when both teams resolve a name; omitted for single-subject, teamless, or non-two-team contexts. ApiError: type: object required: - object - error - meta properties: object: type: string const: error error: type: object required: - code - message properties: code: type: string enum: - bad_request - invalid_api_key - subscription_required - forbidden - not_found - account_locked - rate_limited - rate_limit_unavailable - internal_error message: type: string doc_url: type: string nullable: true param: type: string nullable: true retry_at: type: string format: date-time nullable: true description: >- The recommended next retry instant (RFC3339). Present on every retryable error (reason=pick_not_released, code=rate_limited, code=rate_limit_unavailable, reason=read_model_warming) and omitted otherwise. Always in the future. For pick_not_released it has two regimes: before the 11:00 UTC operating-window start, before a selected pick's stored release, or after a terminal skipped day, it is an exact floor and nothing can publish first. When a publish is overdue or the selector is still hunting inside the operating window, it is a bounded cadence (~60s), not a lower-bound promise; a pick may publish before it. Schedule one request and do not poll. Prefer Retry-After for the duration because it is immune to client clock skew. reason: type: string enum: - cursor_expired - unknown_endpoint - pick_not_released - trader_not_tracked - read_model_warming nullable: true description: >- ADDITIVE (#7209). The specific, actionable cause behind `code`, when there is one more specific than the code itself. `code` keeps its published values, so existing clients are unaffected; new clients branch on `reason`. Omitted when the code already says everything we know. pick_not_released: no Pick of the Day is published for the current product day; schedule one request against retry_at instead of polling. unknown_endpoint: the PATH is not a route on this API -- read GET /api/v1, do not retry. trader_not_tracked: the wallet is real and the URL is right, but the trader is outside the HOT/WARM sync tiers -- stop asking for this wallet. cursor_expired: pagination went stale mid-walk -- re-request the first page and continue. read_model_warming: the requested endpoint cannot serve its read model yet; exact causes are endpoint-specific and can include a cold or contended refresh or a dependency that prevented refresh. Consult that endpoint's contract, retry only this route after the interval, and do not infer dependency health from this reason. meta: $ref: '#/components/schemas/ResponseMeta' PickSportsTeam: type: object description: >- A single sports team or competitor in a Pick of the Day market's sports context. Every field is provider-owned and nullable. properties: label: type: string nullable: true description: >- Team display label as it appears on the market outcome (e.g. "Portugal"). short_label: type: string nullable: true description: Abbreviated team label (e.g. "POR"). full_name: type: string nullable: true description: >- Full team or competitor name (e.g. "Portugal national football team"). provider_id: type: integer nullable: true description: Provider team identifier (Polymarket /teams id). logo: type: string nullable: true description: >- Team crest or flag URL (provider-owned: Polymarket /teams crest for clubs, country flag for national teams and tennis players). color: type: string nullable: true description: Team brand color as a hex string (provider-owned). record: type: string nullable: true description: Win-loss record as a display string (e.g. "12-4"). score: type: string nullable: true description: >- Live or final score as a display string when the game is in play or settled. responses: Unauthorized: description: Missing or invalid API key content: application/json: schema: $ref: '#/components/schemas/ApiError' SubscriptionRequired: description: Active Insider subscription required content: application/json: schema: $ref: '#/components/schemas/ApiError' Forbidden: description: Account access denied content: application/json: schema: $ref: '#/components/schemas/ApiError' PickNotReleased: description: >- No Pick of the Day is published for the current product day. This is expected before the selected pick's kickoff-relative release; each selected pick normally releases one hour before kickoff within the 11:00-19:00 UTC operating window, and on a skipped day no pick is published at all. The body carries error.code="not_found" with error.reason="pick_not_released" (branch on the reason -- the code stays "not_found" because error.code is a frozen contract) plus error.retry_at (RFC3339, always in the future), and the response sets Retry-After. Schedule against those instead of polling -- polling this window is what makes a schedule look like an outage. headers: Retry-After: description: >- Seconds until the recommended next retry. It is an exact floor before the operating-window start, before a selected pick's stored release, or after a terminal skipped day. While a publish is overdue or the selector is hunting, it is a bounded cadence and a pick may publish before it. Always >= 1. Schedule one request (error.retry_at is its absolute RFC3339 twin); do not poll or block a worker thread. schema: type: integer content: application/json: schema: $ref: '#/components/schemas/ApiError' RequestTimeout: description: >- Request exceeded the server's 30-second transport timeout. The timeout response has an empty body because it is generated before handler-level JSON error shaping. Locked: description: Account is locked content: application/json: schema: $ref: '#/components/schemas/ApiError' RateLimited: description: >- Rate limit exceeded. Two independent budgets. (1) 100 requests/minute per user (sliding window), on every authenticated route. (2) On the BATCH routes only: 2500 batch item units/minute per user, reserved before any item is executed. A batch with N requested items costs N item units, including duplicate and invalid items. 2500 = 100 requests x 25 items per batch, which is the most item work a key can buy through the request limiter at all: a caller may spend their entire 100-request minute on full 25-item batches without the item budget being what stops them. The REQUEST budget is the effective ceiling, and batching is never the more expensive choice. The item budget still denies at a sliding-window boundary (both counters carry the previous window forward with a floor, and the item counter runs 25x the request counter), so honor a 429 from either. Over-quota batches return 429 with Retry-After before any item work is done. headers: Retry-After: description: Seconds until rate limit resets. schema: type: integer X-RateLimit-Limit: schema: type: integer X-RateLimit-Remaining: schema: type: integer X-RateLimit-Reset: schema: type: integer X-Request-Id: schema: type: string content: application/json: schema: $ref: '#/components/schemas/ApiError' RateLimitUnavailable: description: >- Redis-backed authenticated rate limiter unavailable; retry after the per-process outage cooldown headers: Retry-After: description: >- Seconds until the middleware will probe the Redis-backed rate limiter again. schema: type: integer X-Request-Id: schema: type: string content: application/json: schema: $ref: '#/components/schemas/ApiError' securitySchemes: bearerAuth: type: http scheme: bearer description: >- API key authentication. Send your key in the Authorization header as `Bearer oxi_sk_live_...`. Live keys require an active Insider subscription and return live data. ````