Pinnacle API Guide 2026

Pinnacle does not offer a public API — here is what you use instead

Pinnacle is the sharpest sportsbook in the world. It operates with 1–3% overround, accepts the largest limits in the industry, and never bans or limits winning accounts. Its closing lines are the gold standard for calculating true probability — used as the primary sharp reference benchmark by every major +EV signal tool and arbitrage scanner.

However, Pinnacle does not offer a public developer API for odds data or bet placement. Their odds are available on their website and app; their historical placement API (api.pinnacle.com) is no longer accessible to retail or semi-institutional users as of 2025.

In 2026, developers access Pinnacle data and execution through three routes:

• Odds data: SportsGameOdds (REST + WebSocket, raw odds with results) and SharpAPI (REST + SSE, with built-in no-vig lines and +EV detection)
• Bet placement: Sharp brokers — SportMarket Pro, MadMarket, and AsianConnect88 — provide documented REST APIs that route bets through Pinnacle and the Asian sharp book network

SharpAPI: the Pinnacle odds API for developers

SharpAPI aggregates real-time Pinnacle odds via proprietary data pipelines and serves them through a clean REST API and SSE streaming endpoint. It was built specifically for the use case of comparing Pinnacle's sharp lines against soft sportsbooks for +EV detection.

Key advantages over DIY approaches:

	SharpAPI	DIY scraping
Setup time	Under 5 minutes	Days to weeks
Reliability	99.9% uptime SLA	Breaks on HTML changes
IP ban risk	None	High — requires proxy rotation
No-vig lines	Pre-calculated (Hobby+)	Build your own math
+EV detection	Built-in (Pro+)	Build from scratch
Real-time streaming	SSE built-in	Poll and diff manually
ToS compliance	Fully compliant	Violates Pinnacle ToS

SharpAPI key endpoints and data format

SharpAPI uses a TypeScript/JavaScript SDK (@sharpapi/client) with a clean async interface:

import { SharpAPI } from '@sharpapi/client';

const sharp = new SharpAPI({ apiKey: 'sk_live_your_key' });

// Get Pinnacle odds for NBA games
const odds = await sharp.odds.list({
  league: 'NBA',
  sportsbooks: ['pinnacle'],
});

// Get +EV opportunities benchmarked against Pinnacle fair value (Pro+)
const ev = await sharp.ev.list({ league: 'NBA' });

// Stream real-time Pinnacle line movements via SSE
const stream = sharp.stream.odds({
  league: 'NBA',
  sportsbooks: ['pinnacle'],
});
stream.on('odds:update', (data) => {
  console.log(data.event, data.market, data.odds_american);
});

The response includes American, decimal, and implied probability formats for each market. No-vig fair odds (the true probability estimate from Pinnacle's sharp line) are exposed on Hobby plans and above.

SharpAPI pricing tiers

Plan	Price	Books	No-vig	+EV detection	Rate limit
Free	$0/mo	2 (incl. Pinnacle)	No	No	12 req/min
Hobby	$79/mo	5	Yes	No	Higher
Pro	$229/mo	15	Yes	Yes	High
Sharp	$399/mo	30+	Yes	Yes	Highest

SportsGameOdds: Pinnacle odds with REST and WebSocket

SportsGameOdds is a developer-first sports odds API that covers Pinnacle alongside 20+ other sportsbooks via a unified endpoint. Its Pinnacle integration includes pre-game lines, live in-play markets, player props, alternative lines, and period-specific markets. Results and settlement data are also available where scoring is supported (look for the scoringSupported field in the response).

Market types covered

• Main markets: moneyline (2-way and 3-way), spread/handicap with vig, totals (over/under)
• Period markets: 1st half, 2nd half, quarters, periods, sets, rounds
• Player props: points, rebounds, assists (NBA); passing yards, rushing yards, TDs (NFL); goals, shots, assists (Soccer)
• Alternative lines: alternative spreads and totals at various price points
• Live in-play: real-time odds during games with the same structure as pre-game

Key features and use cases

Feature	Detail
Data delivery	REST JSON + optional WebSocket push feed
Line movement tracking	lastUpdatedAt timestamp on every odds object
Settlement data	Final scores and results linked to odds IDs via scoringSupported
Sports coverage	20+ sports: NFL, NBA, MLB, NHL, Soccer, Tennis, MMA, and more
Documentation	Interactive API docs at sportsgameodds.com/docs with code snippets in multiple languages
Free trial	Available — set up in under 5 minutes

SharpAPI vs SportsGameOdds: which to use for Pinnacle data

Use case	Best choice	Reason
+EV signal generation with pre-built devig	SharpAPI (Hobby+)	No-vig lines calculated automatically; +EV detection built in on Pro
Raw odds pipeline for proprietary model	SportsGameOdds	Returns raw odds across 20+ books; build your own devig logic
Real-time line movement streaming	SharpAPI (Pro+, SSE) or SportsGameOdds (WebSocket)	Both support push feeds; SharpAPI SSE, SGO WebSocket
Settlement / CLV tracking	SportsGameOdds	Results linked to odds IDs via scoringSupported field
Budget / free tier	SharpAPI free	Pinnacle + 1 other book, 12 req/min, no credit card
Multi-book arbitrage detection	SportsGameOdds or SharpAPI Sharp	Need 20+ books in one call; SGO covers more books broadly

How developers use Pinnacle lines as a sharp reference

The core use case for Pinnacle odds in automated betting is edge detection — comparing Pinnacle's efficient price against soft sportsbooks to find discrepancies.

The workflow:

1. Fetch Pinnacle odds for an event (via SharpAPI or SportsGameOdds)
2. Devig to get no-vig fair probability: fair_prob = raw_prob / (sum of all raw_probs)
3. Convert fair probability to fair odds: fair_odds = 1 / fair_prob
4. Compare each soft book's offered odds against the fair odds
5. Any soft book offering better than fair odds = positive EV bet
6. Edge % = (soft_odds / fair_odds) - 1

SharpAPI automates steps 2–5 on Pro plans. SportsGameOdds delivers the raw data for you to run your own logic.

Pinnacle is also used for Closing Line Value (CLV) measurement. After a market settles, the Pinnacle closing line is the most accurate available benchmark for whether you bet at the right price. Consistently positive CLV over hundreds of bets — measured against Pinnacle's final line — is the strongest indicator of genuine edge in your betting system.

Placing bets through Pinnacle via sharp brokers

Since Pinnacle's direct placement API is not publicly available, programmatic execution at Pinnacle prices happens through sharp broker APIs. Three brokers support this:

Broker	Review	API type	Deposit minimum	Geographic availability
SportMarket Pro	Review →	REST (Mollybet)	€5,000+	Most of EU, Asia, LatAm
MadMarket	Review →	REST (Mollybet)	€5,000+	Most of EU, Asia, LatAm
AsianConnect88	Review →	REST	Varies	Global (outside US/UK)

Brokers route your bets through their own accounts at Pinnacle and other Asian sharp books. You get Pinnacle-level pricing without a direct Pinnacle account. The tradeoff: broker margins or per-bet fees, and deposit minimums that make this unsuitable for small bankrolls.

For +EV bets at soft sportsbooks discovered using Pinnacle's sharp reference, execution is manual (open the soft book, place the bet using the direct link from your signal API) or via a managed service like Smartbet.io for venues where they have integration.

Wiring a Pinnacle odds pipeline: step-by-step

Code sample: SharpAPI + SportsGameOdds Pinnacle odds

SharpAPI (TypeScript/JavaScript SDK):

import { SharpAPI } from '@sharpapi/client';
// npm install @sharpapi/client

const sharp = new SharpAPI({ apiKey: process.env.SHARPAPI_KEY! });

async function getPinnacleEV(league: string) {
  // Fetch +EV opportunities vs Pinnacle fair value (Pro plan required)
  const evOpps = await sharp.ev.list({ league });
  for (const opp of evOpps.data) {
    console.log(
      `${opp.event} | ${opp.market} | ${opp.sportsbook} @ ${opp.odds_american}`,
      `| edge: ${(opp.ev_percent * 100).toFixed(1)}%`,
    );
  }
}

getPinnacleEV('NBA');

SportsGameOdds (REST, Python):

import os, requests

SGO_KEY = os.environ["SGO_API_KEY"]
BASE    = "https://sportsgameodds.com/api/v1"
HEADERS = {"X-Api-Key": SGO_KEY}

def get_pinnacle_odds(sport: str = "NFL", market: str = "moneyline"):
    """Fetch current Pinnacle odds for a sport + market type."""
    r = requests.get(
        f"{BASE}/odds",
        headers=HEADERS,
        params={
            "sportsbooks": "pinnacle",
            "sport":        sport,
            "market":       market,
        },
        timeout=10,
    )
    r.raise_for_status()
    return r.json()

def devig_two_way(odds_home: float, odds_away: float) -> tuple[float, float]:
    """Multiplicative devig for a 2-way market. Returns (fair_home, fair_away)."""
    p_home = 1 / odds_home
    p_away = 1 / odds_away
    total  = p_home + p_away
    return p_home / total, p_away / total

if __name__ == "__main__":
    data = get_pinnacle_odds("NFL", "moneyline")
    for event in data.get("events", []):
        home_odds = event["odds"]["home"]["decimal"]
        away_odds = event["odds"]["away"]["decimal"]
        fair_home, fair_away = devig_two_way(home_odds, away_odds)
        print(f"{event['name']}: fair home={fair_home:.3f} fair away={fair_away:.3f}")
        # Use fair_home / fair_away to detect +EV at soft books

Pinnacle API Frequently Asked Questions