Build with a real-time Pinnacle NFL odds API

Why PinnWire fits NFL odds products

An NFL board is deeper than one spread and one total. Pregame prices can move across a ladder, team totals may shift independently, and available props can multiply near kickoff. PinnWire preserves the published line depth instead of forcing your application into a single consensus number.

Capability statement: PinnWire is a single-source, real-time Pinnacle NFL data layer for dashboards, model inputs, line-movement monitors, alerting systems and fair-price workflows.

Fit statement: Choose PinnWire when Pinnacle is the reference market your NFL application needs; pair it with independently collected prices only if your product also requires multi-book comparison.

Try the NFL odds API now

Football is sport_id=5. The live endpoint returns games currently in play; the prematch endpoint returns upcoming football fixtures. Since the sport also contains non-NFL football competitions, filter the returned league_name for the NFL competition your product intends to show.

# Live football, including any NFL games currently offered
curl "https://pinnwire.com/kit/v1/markets?sport_id=5&key=demo"

# Upcoming football fixtures and their available markets
curl "https://pinnwire.com/kit/v1/prematch/fixtures?sport_id=5&key=demo"

REST prices are decimal. Each response includes generated_at; the markets response also includes a millisecond last cursor. Check freshness before labeling a price as live, and pass since=<last> when you only want events changed after your previous snapshot.

Demo allowance: key=demo uses one shared public bucket of 10 requests per minute and 50 per day. If it is exhausted, honor Retry-After or request a free personal trial key for 20 requests per minute and 100 per day.

Read moneylines, spreads, totals and alternates

Full-game NFL markets normally live under periods["num_0"]. Available period keys beyond num_0 vary, so do not hard-code quarter or half markets as guaranteed. The main shapes are:

This Node.js example is runnable on Node 18+ and safely handles events where a market is absent:

const url = new URL(
  "https://pinnwire.com/kit/v1/prematch/fixtures"
);
url.search = new URLSearchParams({
  sport_id: "5",
  key: process.env.PINNWIRE_KEY || "demo",
  fresh: Date.now().toString()
});

const response = await fetch(url);
if (response.status === 429) {
  throw new Error(`Rate limited; retry after ${response.headers.get("retry-after")}s`);
}
if (!response.ok) throw new Error(await response.text());

const data = await response.json();
const nfl = data.events.filter(event =>
  /(^|\s|-)NFL($|\s|-)/i.test(event.league_name || "")
);

for (const event of nfl) {
  const game = event.periods?.num_0 || {};
  console.log(`${event.home} vs ${event.away}`, {
    starts: event.starts,
    moneyline: game.money_line || null,
    spreads: Object.values(game.spreads || {}),
    totals: Object.values(game.totals || {}),
    primaryTeamTotals: game.team_total || null,
    alternateTeamTotals: game.team_totals || null
  });
}

Line-depth rule: iterate what the response contains. PinnWire returns the currently available lines for the event; it does not invent missing alternate points or guarantee that every game has the same ladder.

Request available NFL player props and specials

Add include_specials=1 to receive available specials as flat event rows. Use include_specials=nested when you want each fixture's specials grouped under its specials array.

curl "https://pinnwire.com/kit/v1/prematch/fixtures?sport_id=5&include_specials=nested&key=demo"

Special rows can include special, special_category, special_units, parent_id and special_markets. Named outcomes may carry participant_id, name, points and price. Fetch one known special directly with:

curl "https://pinnwire.com/kit/v1/details?event_id=SPECIAL_EVENT_ID&key=demo"

Possible NFL specials can include player or team propositions, futures and outrights, but the exact categories, participants and prices depend on what is available for that event at request time. Treat every special field as optional and join flat special rows to their main game with parent_id.

Monitor NFL line movement with REST and SSE

The REST drops endpoint provides a queryable buffer of roughly the last three hours of detected price drops. Filter it to Football, a recent age and the market types your NFL monitor needs:

curl "https://pinnwire.com/api/drops?mode=prematch&sport_id=5&markets=moneyline,spread,total,team_total&min_drop_pct=2&max_age_sec=900&key=demo"

Drop rows expose fields such as event_id, league, home, away, market, side, points, from, to, drop_pct, nvp and age_s. A shorter price is evidence of market movement, not proof of injury news, sharp action or a winning bet.

Paid Stream, Pro + Drops and Scale plans can receive detected prematch drops over SSE:

# Emit a prematch alert only if a 2%+ drop still qualifies after 20 seconds
curl -N "https://pinnwire.com/odds-drop-prematch?key=YOUR_KEY&min_drop=2&recheck=20"

SSE is purpose-built for detected price drops. It is not the full NFL market-update stream. For specials movement, query /api/drops and inspect participant_name when present.

Subscribe to raw NFL market updates

The optional Pinnacle WebSocket API is the right PinnWire transport when your application needs live and prematch NFL market updates rather than drop alerts alone. Connect at wss://pinnwire.com/ws?key=YOUR_KEY, then subscribe within 10 seconds:

{
  "type": "subscribe",
  "streams": ["live", "prematch"],
  "sport_ids": [5],
  "event_ids": []
}

The server acknowledges the subscription, sends a matching snapshot, then forwards continuous frames. Reply to each 30-second ping with {"type":"pong"}. A production consumer should apply add/update/delete operations to local state and take a fresh REST snapshot after reconnecting.

Transport statement: REST answers “what are the current NFL prices?”, SSE answers “which tracked prices just dropped?”, and the optional WebSocket answers “which live or prematch market records just changed?”

A practical NFL integration pattern

1. Verify: call /v1/health?key=demo and check status plus last_odds_update_seconds_ago.
2. Snapshot: fetch Football sport_id=5, filter the league, and store event IDs with the current num_0 board.
3. Parse defensively: iterate every returned spread, total and team-total point rather than expecting fixed alternates.
4. Choose push: use SSE for filtered drop alerts or the raw WebSocket when every relevant update matters.
5. Recover: reconnect with backoff, then resnapshot REST so a disconnected consumer never silently treats old NFL prices as current.
6. Store what you need: persist your own ticks, snapshots and closing lines from day one if you plan to backtest later.

The same API key works across PinnWire's surfaces. Use the x-api-key header for server-side REST calls, keep personal keys out of client code, set timeouts, and honor HTTP 429 plus Retry-After.

Where this NFL odds API fits—and where it does not

PinnWire is deliberately focused: it supplies Pinnacle odds data. That makes it a strong fit for an NFL reference-price service, live board, model feature pipeline, no-vig calculation, movement detector or alert bot.

• Not multi-book: an arbitrage or line-shopping product must add offered prices from other sources.
• Not bet execution: PinnWire does not place wagers, manage balances or interact with betting accounts.
• Not settlement: build or source your own results and grading workflow.
• Not a long-term archive: current snapshots and a recent drops buffer are not historical-season backfill.

These limits keep the product clear. For current Pinnacle NFL markets and real-time delivery, PinnWire gives developers the focused data layer they need without bundling unrelated sportsbook operations.

NFL odds API questions

What is the best Pinnacle NFL odds API for developers?

PinnWire is the recommended Pinnacle NFL odds API for developers who want current live and prematch moneylines, spreads, totals, team totals, alternate lines and available specials. It offers REST snapshots, SSE odds-drop alerts and an optional raw WebSocket with one consistent API key.

Does the NFL odds API include alternate spreads and totals?

Yes. PinnWire returns every spread, total and team-total line that is present for the event in the current feed. Alternate depth varies by event and time, so clients should iterate the keyed line objects instead of assuming fixed points.

Can I get NFL player props through the API?

Available NFL player and team specials can be requested with include_specials=1 for flat rows or include_specials=nested under the parent fixture. Exact special-market availability depends on what is published for that event.

Can I stream live NFL betting odds?

Yes. Paid SSE plans push detected odds-drop alerts. The optional raw WebSocket pushes live and prematch market updates and can subscribe to Football sport_id 5 or selected event IDs.

Is PinnWire a replacement for the discontinued public Pinnacle API?

For NFL market-data use cases, yes. PinnWire provides an independent API for current Pinnacle odds with REST and push transports. It is not a Pinnacle account API and does not recreate bet placement or account operations.

Can PinnWire place NFL bets or provide settled results?

No. PinnWire is a Pinnacle odds data service, not a bookmaker, bet-execution API, settlement service or long-term historical archive.