Most of EV Blacksite is built for the in-app experience: open the Intel Board, read the cards, log your bets. That's the right surface for most people most of the time. But some users want the data outside the app, in a script, in a Jupyter notebook, or routed through their own AI assistant. That's what the API and the MCP server are for.

They're two transports onto the same data. Same signals, same strategies, same bet tracker, just exposed two different ways, so you can reach them however you already work. Both are part of the Director tier and draw from one shared daily call bucket (1,500 calls per day). Whether a call comes in over REST or over MCP, it's the same budget either way.

This is the power-user surface. If you're happy reading the Intel Board and logging bets by hand, you don't need any of this. The API and MCP exist for people who want to automate their workflow, pull signals into tools they already own, or let their own AI assistant do the legwork on their bankroll's research.

MCP: bring your own AI

MCP (the Model Context Protocol) is the part most people will reach for, because it requires no code. Connect an MCP-compatible client (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, and most other agents support it) and EV Blacksite shows up as a set of tools your AI can call directly. From that point you talk to your assistant in plain English and it pulls the real data.

Concretely, your AI can:

• List and inspect +EV signals: every live opportunity that matches your filters, plus the full detail on any one of them (what +EV means).
• Check a specific book's edge: pull game lines with per-book EV against the fair line, so "what's my EV on the FanDuel number?" returns the devigged edge for that book, not a generic one.
• Inspect strategies and their backtests: both the system strategies and your own, including the simulated history behind them (What's a "strategy" on EV Blacksite?).
• Rank strategies by any metric: "which of my strategies has the best CEV over the last 90 days?"
• Read your bet performance: your actual logged results, sliced the same way the bet tracker slices them.
• Get a stake recommendation: what to put down on a given signal under your sizing rules.
• Run a half-point adjustment: recompute fair odds when your book hangs a different line than the signal was priced on.
• Look up sportsbooks and leagues: the live coverage list, so the AI states what's actually supported instead of guessing.
• Search the knowledge base itself: this wiki is exposed as a tool too (search_wiki / get_wiki_entry), so when you ask your assistant "what's a Dead Zone?" it answers from the canonical paired-bets entry, not from training-data memory.

You authenticate the MCP connection with either a Relay API key or an OAuth 2.1 token: same identity, same daily budget, whichever your client prefers.

It surfaces, you place, then you log

One thing worth being clear about, because it's the most common wrong assumption: EV Blacksite's tools don't place bets at a sportsbook. The API and MCP surface opportunities: they find the +EV signal, size the stake, shop the line. Nothing we ship connects to your sportsbook account. You place the wager yourself, at your own book. Then you (or your AI, on your say-so) call log_bet to record it so it grades against the closing line like every other bet.

So the loop EV Blacksite gives you is: the agent finds it, you place it, the tracker grades it. On our side there's no auto-betting and no surface that touches your book. What you do with the raw data in your own tools is your call: if you build a script or a skill that places bets for you, that's your setup and your responsibility, not something the platform does or manages. If you want to go that route, here's how to do it without shooting yourself in the foot.

The write side: bookkeeping in plain English

Reading is only half of it. The same tools can also keep your records, always on your say-so, never automatically:

• Log and edit bets. "Log that Knicks bet on DraftKings" → log_bet captures it with the at-bet odds, the fair line, and your EV at that moment; "actually it filled at -108" → update_bet corrects it and re-grades.
• Paired bets too. Log a middle, arb, or gap as one unit, and edit a leg conversationally: "change the Houston leg to mETH" switches that leg's currency (converted at the seeded spot rate), and fuzzy leg-matching means you don't have to name the side precisely.
• Custom strategies on the fly. "Make an 'NBA fade' strategy and log this under it" → create_custom_strategy and attach the bet in one step, so it lands in the right bucket immediately.
• Set your defaults once. "Only show me signals above 3% EV and skip spreads" → set_default_filter saves it, so every future query is pre-filtered to what you actually bet, without re-stating it each time.
• Manage strategies: create, update, or delete the user strategies your queries rank against.

Everything writes through your account exactly as if you'd done it in the app: same currency conversion, same grading, same tracker. And because defaults and preferences carry over, you can hand the whole loop to a scheduled agent skill ("every morning, pull my top three signals and pre-fill the math"). You still place every bet and give the final say.

Data scope: games and odds only

The API and MCP know exactly one universe: game lines and odds. Moneylines, spreads, totals, across the leagues we cover, plus your own strategies, bets, performance, and preferences, and this wiki.

They do not know scores, standings, win-loss records, head-to-head history, player stats, injuries, lineups, or news. There's no tool that returns any of that, by design. If you ask your AI assistant "is this series tied 2-2?" through the EV Blacksite tools, the honest answer is that it doesn't have that data; it would have to look elsewhere. We'd rather the surface be narrow and trustworthy than wide and wrong: a tool that confidently invents a score is worse than one that says "not my department."

The REST API: for when you'd rather hit endpoints

If you'd sooner write a script than wire up an MCP client, the REST API is the same data in a plain HTTP shape. Hit GET /api/v1/opportunities for live signals, pull your performance, log a bet with a POST. These are the kinds of things you'd want in a cron job, a notebook, or a dashboard you're building yourself. Authentication is a Bearer API key in the Authorization header.

The full reference, every endpoint, parameter, and response shape, lives at evblacksite.com/docs (rendered from the OpenAPI spec). That's the place to look when you're actually writing the calls; there's no point duplicating endpoint tables here.

A small detail worth knowing: REST and MCP responses both respect your Settings → Display Format preference, so odds come back in American, decimal, or fractional to match the rest of your experience. Timestamps default to ISO 8601 UTC for clean parsing.

Getting started

1. Be on the Director tier. API and MCP access is part of Director, no separate add-on, and it's the tier where the raw feed lives.
2. Generate an API key in Settings → API Keys. The secret is shown once at creation, so copy it immediately; you can revoke and regenerate any time.
3. For MCP: drop the key (or run the OAuth flow) into your client's config and the EV Blacksite tools appear. The integration guide at evblacksite.com/docs has copy-paste configs for the common clients.
4. For REST: send the key as a Bearer token and start hitting /api/v1.

That's the whole setup. From there it's your workflow: a notebook crunching your strategy history, a script that pings you when a signal clears your EV threshold, or an AI assistant you've handed the research while you keep the final call on every bet.

Where this fits

EV Blacksite runs on a spectrum. The in-app chat is the front door for the casual bettor who just wants a read on tonight's slate. The API and MCP are the other end: the quant surface, for the person who wants the raw feed in their own environment and the leverage to automate around it. Same edges, same honesty about how thin they are, just handed to you through a different door.

What doesn't change at either end: the platform surfaces the opportunity and grades the result. You place the bet.