# PinnFeed — Pinnacle-Quoten-API in Echtzeit (Deutsch)
> PinnFeed (https://pinnfeed.io) ist eine Entwickler-API für Pinnacle-Sportwettenquoten in Echtzeit: ein normalisierter WebSocket mit serverseitigen Filtern und Delta-Updates, REST-Snapshots, faire Quoten ohne Marge (fair, fairProb, margin) für jeden Markt, eine Historie der Schlussquoten und ein gehosteter MCP-Server für KI-Assistenten. 13 Sportarten. PinnFeed (pinnfeed.io, mit doppeltem n) ist eine Pinnacle-Quoten-API, nicht die Pinterest-App PinFeed. Unabhängiger Dienst, nicht mit Pinnacle verbunden. Bildungsinhalte für Erwachsene ab 18 Jahren.
Wichtige Fakten:
- Pläne (EUR, inkl. MwSt., wo anwendbar, monatlich): Free 0 € (REST, 30 s Verzögerung, 1 Req/s, 1.000 Anfragen/Tag, 2 Sportarten); Hobby 29 €/Monat (REST in Echtzeit, kein WebSocket, 2 Req/s, 3 Sportarten); Builder 99 €/Monat (der WebSocket-Plan: 3 Verbindungen, REST 10 Req/s, alle 13 Sportarten, alle Märkte und Props, Schlussquoten); Pro 199 €/Monat (10 WebSocket-Verbindungen, 30 Req/s, Raw Frames); Enterprise 50 Verbindungen (mehr auf Anfrage).
- 3 Tage kostenlos für Hobby, Builder und Pro; Karte erforderlich, Abbuchung nach Tag 3, sofern nicht gekündigt. Zahlung per Karte (Stripe) oder Krypto.
- Free- und Hobby-Keys erhalten `403 plan_lacks_ws` auf /v1/stream.
- Preisaussage, präzise formuliert: Stand 9. November 2026 war PinnFeed Builder für 99 €/Monat (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten für Live und Pre-Match gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt odds-api.io auf etwa 98,33 €/Monat. Quellen: https://pinnfeed.io/de/compare
- WebSocket: wss://pinnfeed.io/v1/stream — zuerst ein Snapshot, dann Deltas; Ping/Pong alle 20 s.
- REST: https://pinnfeed.io/v1 (sports, events, odds, drops, closing). Authentifizierung: Header x-api-key.
- MCP: https://pinnfeed.io/mcp (Streamable HTTP).
- Die technische Dokumentation ist auf Englisch: https://pinnfeed.io/docs
## Seiten
- [Pinnacle-Quoten in Echtzeit, per WebSocket](https://pinnfeed.io/de/): Pinnacle-Quoten per WebSocket und REST: Live- und Pre-Match-Deltas, No-Vig-Fair-Odds, Closing Lines, 13 Sportarten und MCP. Builder 99 €/Monat.
- [Preise der Pinnacle-Quoten-API](https://pinnfeed.io/de/pricing): PinnFeed-Tarife in EUR (inkl. MwSt., wo anwendbar): Free 0 €, Hobby 29 € REST, Builder 99 € WebSocket, Pro 199 €. 3-Tage-Trial; Karte oder Crypto.
- [Der niedrigste veröffentlichte Preis bei monatlicher Abrechnung für einen Pinnacle-Quoten-WebSocket für Live und Pre-Match](https://pinnfeed.io/de/cheapest-pinnacle-odds-websocket): Stand 9. Nov. 2026: Builder 99 €/Monat (inkl. MwSt.) günstigster veröffentlichter Preis bei monatlicher Abrechnung für Live+Pre-Match-Pinnacle-WebSocket.
- [Pinnacle-Quoten-APIs im Vergleich: wer die Preise streamt und was es kostet](https://pinnfeed.io/de/compare): Vergleich WebSocket vs. Polling und veröffentlichte Preise von Pinnacle-Quoten-APIs (9. Nov. 2026): PinnFeed, oddssea, odds-api.io, oddspush, pinnwire.
- [Häufige Fragen zu PinnFeed](https://pinnfeed.io/de/faq): Häufige Fragen: Tarife, Builder-WebSocket 99 €/Monat, REST, Fair-Odds, Closing Lines, MCP, 3-Tage-Trial und Abrechnung. Klare Kurzantworten.
- [NFL-Spieler-Props-API mit Pinnacle-Preisen](https://pinnfeed.io/de/answers/nfl-player-props-odds-api-pinnacle): NFL-Spieler-Props von Pinnacle per API auf Builder: Special-Events mit parentId unter american-football. REST und WebSocket.
- [Mit PinnFeed und KI bauen](https://pinnfeed.io/de/vibe-coding): Pinnacle-Quoten per KI: ps_live_-Key in 60 s, Prompts für Cursor/Claude/ChatGPT/Lovable/Replit/Bolt plus MCP. Keys nie hardcoden.
- [Quickstart — Key zur ersten Quote](https://pinnfeed.io/de/quickstart): Von Signup zur ersten Pinnacle-Quote in einer Minute: PINNFEED_KEY exportieren, curl, Python, Node und Google Sheets. WebSocket und MCP verlinkt.
- [Fußball-Quoten-Feed von Pinnacle](https://pinnfeed.io/de/answers/football-odds-feed-pinnacle): Fußballquoten von Pinnacle per REST oder WebSocket: 1X2, asiatisches Handicap, Tore-Totals und Team-Totals, mit fairen Quoten, Marge und maxStake je Markt.
- [Antworten auf konkrete Fragen zur Pinnacle-Quoten-API](https://pinnfeed.io/de/answers): Kurze Antwortseiten zur Pinnacle-Quoten-API und zum WebSocket von PinnFeed: Fußball, Tarife, Kelly, Marge, Steam, CLV-Tabellen, Schlüssel und mehr.
- [NBA-Moneyline-Quoten von Pinnacle in Echtzeit](https://pinnfeed.io/de/answers/pinnacle-nba-moneyline-odds-api): NBA-Moneyline-Quoten von Pinnacle mit PinnFeed in Echtzeit abrufen oder streamen. Der Sport-Slug ist basketball; funktionierende REST- und WebSocket-Beispiele.
## Anleitungen
- [Pinnacle-Quoten in Echtzeit per WebSocket mit Python und Node](https://pinnfeed.io/de/guides/pinnacle-odds-websocket-python-node): Pinnacle-Quoten-WebSocket in Python oder Node in ~60 Zeilen: Snapshot, Deltas, Pings und Reconnect. Fertiger Code mit PinnFeed Builder.
- [Dropping Odds und Steam Moves bei Pinnacle in Echtzeit erkennen](https://pinnfeed.io/de/guides/dropping-odds-steam-detection): Steam und Dropping Odds auf Pinnacle in Echtzeit erkennen: Python-Rolling-Window am PinnFeed-WebSocket, maxStake-Filter und /v1/drops.
- [Value Bets bei Soft-Buchmachern mit Pinnacles fairen Quoten](https://pinnfeed.io/de/guides/value-betting-no-vig-fair-odds): Finde +EV-Wetten, indem du Soft-Quoten mit Pinnacle No-Vig-Fair-Odds vom PinnFeed-WebSocket vergleichst. Python-Detektor mit EV-Rechnung.
- [Deinen Closing Line Value gegen Pinnacles Schlussquote messen](https://pinnfeed.io/de/guides/closing-line-value-clv-tracking): Closing Line Value (CLV) gegen Pinnacle-Schlussquoten mit PinnFeed /v1/closing messen. Python-Skript, das deine Fills bewertet.
- [Einen Telegram-Tipp-Bot mit Pinnacle-Live-Quoten bauen](https://pinnfeed.io/de/guides/telegram-picks-bot): Node.js-Telegram-Bot, der Pinnacle-Steam in Echtzeit aus dem PinnFeed-WebSocket postet. BotFather, Dry-Run und vollständiger Code.
- [Pinnacle-Live-Quoten in ChatGPT und Claude mit MCP](https://pinnfeed.io/de/guides/pinnacle-odds-chatgpt-claude-mcp): Live-Pinnacle-Quoten in ChatGPT, Claude und Cursor mit PinnFeed Hosted MCP unter /mcp. Setup, Tool-Liste und Beispiel-Prompts.
- [Pinnacle-Quoten in Google Sheets](https://pinnfeed.io/de/guides/pinnacle-odds-google-sheets): Pinnacle-Quoten per Apps Script gegen die PinnFeed-REST-API in Google Sheets laden. Free-Plan reicht für ein Board mit 30 s Verzögerung.
- [Einen Discord-Picks-Bot mit Live-Quoten von Pinnacle bauen](https://pinnfeed.io/de/guides/discord-picks-bot): Node.js-Bot, der Pinnacle-Steam per Webhook aus dem PinnFeed-WebSocket in einen Discord-Kanal postet. Embeds, 429-Behandlung und vollständiger Code.
## Mehr
- [English llms.txt](https://pinnfeed.io/llms.txt)
- [Volltext auf Deutsch](https://pinnfeed.io/llms-de-full.txt)
---
Source: https://pinnfeed.io/de/
# Pinnacle-Quoten in Echtzeit, per WebSocket
PinnFeed ist eine **Pinnacle-Quoten-API** für alle, die programmieren: ein einziger **WebSocket**, der zuerst einen Snapshot schickt und danach nur noch, was sich geändert hat. Du filterst serverseitig nach Sportart, Liga und Markt, jede Linie kommt mit ihrer **fairen Quote ohne Marge**, und die **Schlussquote** wird archiviert. Ein Pinnacle-Konto brauchst du nicht.
PinnFeed (pinnfeed.io, mit doppeltem n) ist eine Pinnacle-Quoten-API, nicht die Pinterest-App PinFeed. Der Free-Tarif braucht keine Karte (REST mit 30 s Verzögerung, 2 Sportarten).
**Der WebSocket-Plan ist Builder, 99 €/Monat** (inkl. MwSt., wo anwendbar): Echtzeit-Push, alle 13 Sportarten, alle Märkte und Schlussquoten. Jeder bezahlte Plan startet mit **3 Tagen kostenlos** (Karte erforderlich; Abbuchung am vierten Tag, sofern du nicht kündigst).
## Gebaut für den Bot, nicht für den Browser
Alles, was du sonst selbst schreiben müsstest (Reconnects, Merge-Regeln, Quotenumrechnung, Margenentfernung, Erkennung des Anpfiffs), erledigen wir einmal auf unserer Seite. Bei dir kommt sauberes JSON an.
- **Push statt Polling.** Einmal abonnieren, dann kommen Deltas. Ein ruhiger Markt kostet dich nichts.
- **Serverseitige Filter.** Nach Sportart, Liga, Event, Markttyp sowie Live oder Pre-Match. Du bekommst nur, was du anforderst.
- **Faire Quoten und Schlussquoten.** Jeder Markt trägt seine Marge und eine faire Dezimalquote pro Ausgang. Beim Anpfiff wird der letzte Pre-Match-Preis als Schlussquote gespeichert.
- **Stabiles Schema.** Events und Märkte mit stabilen ids, Dezimal- und amerikanische Quoten, Linien, Perioden, Maximaleinsatz und Cutoff-Zeit.
- **Gehostetes MCP.** Ein MCP-Server unter `/mcp` lässt Claude, Cursor, Copilot und ChatGPT mit deinem Key Live-Quoten, Dropping Odds und Schlussquoten lesen.
- **Keys in Selbstbedienung.** Keys anlegen, umbenennen und widerrufen, Nutzung pro Key ansehen und den Plan im Dashboard wechseln.
Die 13 Sportarten: Fußball, Tennis, Basketball, Eishockey, American Football, Baseball, Rugby, MMA, Boxen, Volleyball und Handball, E-Sport, Golf und Cricket.
## Ein Client, der funktioniert
Verbinden, Live-Fußball abonnieren und jede Bewegung sehen. Es ist ein normaler WebSocket mit JSON: Python, Node oder jede andere Sprache.
```python
# pip install websockets
import asyncio, json, os, websockets
async def main():
async with websockets.connect("wss://pinnfeed.io/v1/stream",
additional_headers={"x-api-key": os.environ["PINNFEED_KEY"]}) as ws:
await ws.send(json.dumps({"type": "subscribe", "sports": ["soccer"], "live": True, "markets": ["moneyline"], "main": True}))
async for raw in ws:
msg = json.loads(raw)
if msg["type"] == "ping":
await ws.send('{"type":"pong"}') # auf den Heartbeat antworten, sonst schließt der Server
elif msg["type"] == "delta":
print(len(msg["changes"]), "changes")
asyncio.run(main())
```
Den vollständigen Client mit Quotenbuch im Speicher und Reconnect findest du in der [Python- und Node-Anleitung](/de/guides/pinnacle-odds-websocket-python-node).
## Erst der Snapshot, dann nur Änderungen
- **Snapshot und Deltas.** Beim Abonnieren ein Snapshot in mehreren Teilen, danach nur die Märkte, die sich ändern, gebündelt pro Update.
- **Entfernungen sind explizit.** Gesperrte oder abgerechnete Märkte kommen als `op: "remove"`, damit dein Quotenbuch nie veraltete Preise zeigt.
- **REST spiegelt den Socket.** Dieselben Objekte liefert `GET /v1/odds` für Cronjobs und Backfills.
## Push gegen Polling: die Rechnung
Ein Client, der pollt, sieht eine Änderung erst bei seiner nächsten Anfrage: im Schnitt ein halbes Intervall zu spät, im schlimmsten Fall ein ganzes, plus die Round Trip Time. Ein WebSocket hat kein Intervall. Das ist Arithmetik, kein Benchmark, du kannst es selbst nachrechnen.
| Kennzahl | WebSocket-Push | REST alle 5 s | REST alle 30 s | REST alle 60 s |
|---|---|---|---|---|
| Wann du eine Änderung siehst | Sobald sie passiert | Beim nächsten Poll | Beim nächsten Poll | Beim nächsten Poll |
| Durchschnittliche Zusatzverzögerung | Keine | 2,5 s | 15 s | 30 s |
| Maximale Zusatzverzögerung | Keine | 5 s | 30 s | 60 s |
| Anfragen pro Stunde, ein Endpoint | 1 Verbindung | 720 | 120 | 60 |
Netzwerklaufzeit und Verarbeitung betreffen beide Varianten und sind nicht eingerechnet. Unser REST im Free-Plan ist absichtlich um 30 s verzögert; REST in Hobby und alle WebSocket-Pläne laufen in Echtzeit.
## Preise
| Plan | Preis (EUR, inkl. MwSt., wo anwendbar) | Was drin ist |
|---|---|---|
| Free | 0 € | REST mit 30 s Verzögerung, 2 Sportarten, 1 Req/s, 1.000 Anfragen/Tag, ohne Karte |
| Hobby | 29 €/Monat | REST in Echtzeit, 3 Sportarten, 2 Req/s, **kein WebSocket** |
| **Builder** | **99 €/Monat** | **Der WebSocket-Plan**: 3 Verbindungen, alle 13 Sportarten, alle Märkte und Props, REST 10 Req/s, Schlussquoten |
| Pro | 199 €/Monat | 10 WebSocket-Verbindungen, 30 Req/s, Raw Frames |
| Enterprise | Individuell | Exporte des Schlussquoten-Archivs, SLA und kommerzielle Lizenz |
Der WebSocket-Preis mit seiner Einschränkung: Stand 9. November 2026 war Builder der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Pinnacle-Quoten-WebSocket **für Live und Pre-Match** gefunden haben. Zahlen, Quellen und Vorbehalte stehen auf der [Preisseite zum WebSocket](/de/cheapest-pinnacle-odds-websocket). [Alle Limits ansehen](/de/pricing).
Konkrete Fragen mit Code: [Antworten](/de/answers) · [Guides](/de/guides).
## Häufige Fragen
### Gibt es noch eine öffentliche Pinnacle-API?
Pinnacle hat seine öffentliche API im Juli 2025 für die meisten Nutzer geschlossen. PinnFeed ist ein unabhängiger Dienst, der Pinnacle-Preise über einen normalisierten WebSocket und eine REST-API an Entwickler liefert. Ein Pinnacle-Konto brauchst du nicht.
### Warum ein WebSocket statt Polling einer REST-API?
Ein Client, der pollt, sieht eine Änderung erst bei der nächsten Anfrage, im Schnitt also ein halbes Intervall zu spät. Über den WebSocket pusht PinnFeed jede Änderung, sobald sie bei unserem Server ankommt, gefiltert auf dein Abo und mit fairen Quoten. Builder (99 €/Monat) ist der WebSocket-Plan.
### Was ist eine faire Quote (ohne Marge)?
Pinnacles Preise enthalten eine Marge. Wir entfernen sie mit der multiplikativen Methode und liefern für jeden Ausgang die faire Wahrscheinlichkeit und die faire Dezimalquote. So vergleichst du jeden Buchmacher ohne eigene Rechnung mit der schärfsten Linie.
### Gibt es einen kostenlosen Plan?
Ja. Free gibt REST-Zugriff auf zwei Sportarten mit 30 Sekunden Verzögerung und 1.000 Anfragen pro Tag, ohne Karte. Hobby (29 €/Monat) macht REST in Echtzeit; Builder (99 €/Monat) bringt den Echtzeit-WebSocket dazu.
### Kann ich jederzeit kündigen?
Ja. Jeder bezahlte Plan startet mit 3 Tagen kostenlos (Karte erforderlich, Abbuchung am vierten Tag, sofern du nicht kündigst) und läuft monatlich über Stripe; Kündigung oder Planwechsel mit einem Klick im Dashboard. Krypto-Pläne werden für 1, 3 oder 12 Monate vorausbezahlt und verlängern sich nie automatisch.
### Sind die Inhalte nur für Erwachsene?
PinnFeed ist eine Self-Serve-API für Echtzeit-Pinnacle-Quoten: ein normalisierter WebSocket (Builder 99 €/Monat) plus REST, No-Vig-Fair-Odds, Closing-Line-Historie, 13 Sportarten und ein gehosteter MCP-Server. Free 0 € (REST, 30 s Verzögerung); Hobby 29 €/Monat nur REST; Pro 199 €/Monat. 3-Tage-Trial auf bezahlten Plänen. Stand 9. November 2026 war Builder der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung für einen Pinnacle-WebSocket mit Live + Pre-Match (Quellen).
- WebSocket-Plan
- Builder · 99 €/Monat · 3 Verbindungen · Live + Pre-Match · alle 13 Sportarten
- Auch
- Free 0 € · Hobby 29 €/Monat (ohne WS) · Pro 199 €/Monat · Enterprise individuell
- Trial
- 3 Tage auf Hobby, Builder und Pro (Karte erforderlich)
- Stack
- WebSocket + REST · No-Vig-Fair-Odds · Closing Lines · MCP
Ja. PinnFeed ist ein Daten-Tool, und die Inhalte dienen der Bildung, für Erwachsene ab 18 Jahren. Nichts hier ist ein Tipp oder ein Gewinnversprechen. Spiele verantwortungsvoll und nur dort, wo es legal ist.
---
Source: https://pinnfeed.io/de/pricing
# Preise der Pinnacle-Quoten-API
Starte kostenlos mit verzögerten REST-Daten oder teste jeden bezahlten Plan **3 Tage kostenlos**. **Builder ist der WebSocket-Plan** (99 €/Monat): Pinnacle-Quoten per Echtzeit-Push, alle Sportarten, alle Märkte und die Historie der Schlussquoten. Jederzeit kündbar.
PinnFeed (pinnfeed.io, mit doppeltem n) ist eine Pinnacle-Quoten-API, nicht die Pinterest-App PinFeed.
## Pläne
| Plan | Monatlich (EUR, inkl. MwSt., wo anwendbar) | Was der Key kann | Starten |
|---|---|---|---|
| Free | 0 € | REST-Snapshots (30 s Verzögerung) · 2 Sportarten nach Wahl · Hauptmärkte · 1.000 Anfragen/Tag · ohne Karte | [Kostenloser Key](/signup) |
| Hobby | 29 €/Monat | REST in Echtzeit (ohne Verzögerung) · 3 Sportarten · Hauptmärkte + faire Quoten · 2 Req/s · kein WebSocket | [3 Tage kostenlos](/start/hobby) |
| **Builder · der WebSocket-Plan** | **99 €/Monat** | WebSocket-Push in Echtzeit (3 Verbindungen) · alle 13 Sportarten · alle Märkte, Alternativlinien, Props und Langzeitwetten · REST 10 Req/s · Historie der Schlussquoten | [3 Tage kostenlos](/start/builder) |
| Pro | 199 €/Monat | 10 WebSocket-Verbindungen · alles aus Builder · optionale Raw Frames · REST 30 Req/s · bevorzugter Support | [3 Tage kostenlos](/start/pro) |
| Enterprise | Individuell | 50 WebSocket-Verbindungen (mehr auf Anfrage) · Massenexporte der Schlussquoten (CSV/Parquet) · SLA und kommerzielle Lizenz | [Schreib uns](mailto:support@pinnfeed.io?subject=PinnFeed%20Enterprise) |
Preise in Euro, monatliche Abrechnung, inkl. MwSt., wo anwendbar; Unternehmen können im Checkout ihre USt-IdNr. angeben. Du zahlst per Karte über Stripe oder zahlst 1, 3 oder 12 Monate im Voraus in USDC, USDT, SOL oder BTC über das Dashboard.
## Alle Limits im Überblick
| Limit | Free | Hobby | Builder | Pro | Enterprise |
|---|---|---|---|---|---|
| Echtzeit-WebSocket | — | — (nur REST) | 3 Verbindungen | 10 Verbindungen | 50 (mehr auf Anfrage) |
| REST-API | 1 Req/s · 1.000/Tag | 2 Req/s | 10 Req/s | 30 Req/s | 100 Req/s |
| Kostenloser Test | — | 3 Tage | 3 Tage | 3 Tage | — |
| Datenverzögerung | 30 Sekunden | Echtzeit | Echtzeit | Echtzeit | Echtzeit |
| Sportarten | 2 nach Wahl | 3 nach Wahl | Alle 13 | Alle 13 | Alle 13 |
| Märkte | Hauptmärkte | Hauptmärkte | Alle Linien, Perioden, Props und Langzeitwetten | Alles + Raw Frames | Alles + Raw |
| Faire Quoten ohne Marge | ✓ | ✓ | ✓ | ✓ | ✓ |
| Historie der Schlussquoten | — | — | ✓ | ✓ | Massenexporte |
| MCP-Server für KI | ✓ verzögert | ✓ | ✓ | ✓ | ✓ |
| Preis (EUR, inkl. MwSt., wo anwendbar) | 0 € | 29 €/Monat | 99 €/Monat | 199 €/Monat | Individuell |
| Support | Docs | E-Mail | E-Mail | Bevorzugt | SLA |
Wie steht Builder im Vergleich da? Stand 9. November 2026 war Builder für 99 €/Monat der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Pinnacle-Quoten-WebSocket **für Live und Pre-Match** gefunden haben; ein reiner Pre-Match-WebSocket wird günstiger angeboten. Details und Quellen im [Preisvergleich](/de/cheapest-pinnacle-odds-websocket).
## Fragen zur Abrechnung
### Gibt es einen kostenlosen Test?
Ja. Hobby, Builder und Pro starten mit 3 Tagen kostenlos. Im Checkout wird eine Karte hinterlegt und nach Ablauf von Tag 3 automatisch belastet, sofern du nicht vorher kündigst. Ein Test pro Person.
### Kann ich mit Krypto oder für ein Jahr zahlen?
Ja. Im Dashboard kannst du 1, 3 oder 12 Monate in USDC oder USDT (Ethereum, Base, Arbitrum, Polygon, BNB Chain, Solana), SOL oder BTC vorauszahlen. Stablecoins sind Dollar-Token, daher wird der Euro-Preis bei Rechnungserstellung zum EZB-Referenzkurs umgerechnet. Krypto-Pläne werden mit der On-Chain-Bestätigung aktiviert und verlängern sich nie automatisch.
### Enthält Hobby den WebSocket?
Nein. Hobby ist nur REST in Echtzeit. Der WebSocket beginnt bei Builder (99 €/Monat), dem WebSocket-Plan, mit 3 Verbindungen, allen 13 Sportarten und allen Märkten.
### Was passiert, wenn eine Zahlung fehlschlägt?
Stripe versucht die Abbuchung erneut. Dein Plan bleibt während einer Kulanzfrist von 3 Tagen aktiv und fällt danach auf Free zurück, bis die Zahlung durchgeht.
### Darf ich die Daten kommerziell nutzen?
Ja, in deinen eigenen Produkten und gemäß der Acceptable Use Policy. Den Rohfeed als konkurrierenden Datendienst weiterzuverteilen erfordert eine Enterprise-Lizenz.
### Berechnet ihr MwSt.?
- WebSocket-Plan
- Builder · 99 €/Monat · 3 Verbindungen · Live + Pre-Match · alle 13 Sportarten
- Auch
- Free 0 € · Hobby 29 €/Monat (ohne WS) · Pro 199 €/Monat · Enterprise 50 (mehr auf Anfrage)
- Trial
- 3 Tage auf Hobby, Builder und Pro (Karte erforderlich)
- Stack
- WebSocket + REST · No-Vig-Fair-Odds · Closing Lines · MCP
Die Preise sind in Euro und enthalten die MwSt., wo anwendbar: Die genannten EUR-Preise enthalten die MwSt., wo anwendbar, und Stripe ermittelt den MwSt-Anteil im Checkout anhand deiner Rechnungsadresse. Dieser Anteil kann 0 sein, bei Übergang der Steuerschuldnerschaft oder wenn keine MwSt. anfällt.
---
Source: https://pinnfeed.io/de/cheapest-pinnacle-odds-websocket
# Der niedrigste veröffentlichte Preis bei monatlicher Abrechnung für einen Pinnacle-Quoten-WebSocket für Live und Pre-Match
Stand 9. November 2026 war PinnFeed Builder für **99 €/Monat** (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten **für Live und Pre-Match** gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt odds-api.io Solo + WebSocket auf etwa 98,33 €/Monat. Der [vollständige Vergleich](/de/compare) verlinkt die Preisseite jedes Anbieters.
Wenn PinnFeed nicht zu dir passt, erklärt [Alternativen zur Pinnacle-Quoten-API](/alternatives) (auf Englisch), wann welcher andere Anbieter die bessere Wahl ist.
## Was du für 99 € im Monat bekommst
- **Echtzeit-Push.** Preise werden gepusht, sobald sie sich ändern: ein Snapshot beim Abonnieren, danach nur Deltas. Kein Polling und kein Anfragekontingent auf dem Socket.
- **3 WebSocket-Verbindungen**, alle 13 Sportarten, Live und Pre-Match.
- **Alle Märkte**: Siegwette (Moneyline), Handicap, Über/Unter und Team-Totals jeder Periode, Alternativlinien, Props und Langzeitwetten.
- **Faire Quoten ohne Marge** und die Buchmachermarge für jeden Markt, damit du Value Bets ohne eigene Rechnung bewerten kannst.
- **Historie der Schlussquoten** zur CLV-Messung, über `/v1/closing`.
- **REST mit 10 Anfragen pro Sekunde** im selben Schema, für Snapshots und Backfills.
- **Gehosteter MCP-Server**, damit ChatGPT, Claude oder Cursor dieselben Quoten lesen.
## So steht der Preis im Vergleich da
| Option | Was du pro Monat zahlst | Push? | Live + Pre-Match? |
|---|---|---|---|
| oddssea Prematch | 59 $ (≈ 53 €) | WebSocket | Nur Pre-Match |
| **PinnFeed Builder** | **99 €** (inkl. MwSt., wo anwendbar) | WebSocket | **Ja** |
| odds-api.io Solo + WebSocket | 98 £ pro Monat (≈ 117 €) oder 980 £ pro Jahr (≈ 98,33 € pro Monat) | WebSocket | Ja (mehrere Buchmacher) |
| oddspush REST + WebSocket | 138 $ (≈ 124 €), 1 Monat Vorauszahlung | WebSocket | Ja |
| oddssea Live | 149 $ (≈ 133 €) | WebSocket | Ja |
| pinnwire Pro + Raw WebSocket | 89 $ + 89 $ = 178 $ (≈ 159 €) | WebSocket | Ja |
| Reine Pinnacle-Reseller: REST-Plan + WebSocket-Add-on | 99 $ + 99 $ = 198 $ (≈ 177 €) | WebSocket | Ja |
| Unabated Concierge | 799 $ (≈ 716 €), nur fünf US-Ligen | SSE | Eingeschränkte Sportarten |
| OpticOdds | Nur auf Anfrage | SSE, RabbitMQ | — |
| OddsJam API | Nur auf Anfrage | Push-Stream, Protokoll nicht angegeben | — |
| The Odds API | Ab 30 $ (≈ 27 €) | Nein, nur Polling | Ja (Polling) |
Preise so, wie sie am 9. November 2026 auf der Seite des jeweiligen Anbieters veröffentlicht waren. Die Euro-Umrechnungen nutzen den EZB-Referenzkurs vom 6. November 2026 (1 USD = 0,89566 €, 1 GBP = 1,1988 €) und sind gerundet. Quellen: [oddssea.dev](https://oddssea.dev/), [oddspush.com](https://oddspush.com/#pricing), [pinnwire.com](https://pinnwire.com/), [odds-api.io/pricing](https://odds-api.io/pricing).
Ehrliche Vorbehalte: Ein **reiner Pre-Match**-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat ≈ 53 €); der Jahresplan von odds-api.io ist pro Monat etwas günstiger, wenn du das Jahr im Voraus zahlst (≈ 98,33 €); und The Odds API ist günstiger, wenn dir Polling reicht, hat aber keinen WebSocket.
## Einstiege mit kleinerem Budget
- **Free**: 0 €, REST-Snapshots mit 30 Sekunden Verzögerung, 2 Sportarten, 1.000 Anfragen pro Tag. Genug, um deinen Parser zu bauen und zu testen.
- **Hobby**: 29 €/Monat, REST in Echtzeit ohne Verzögerung, 3 Sportarten. Kein WebSocket.
- **Builder**: 99 €/Monat, der WebSocket-Plan. [Builder auf der Preisseite ansehen](/de/pricing#plan-builder).
## In wenigen Zeilen verbunden
```python
# pip install websockets
import asyncio, json, os, websockets
async def main():
async with websockets.connect("wss://pinnfeed.io/v1/stream",
additional_headers={"x-api-key": os.environ["PINNFEED_KEY"]}) as ws:
await ws.send(json.dumps({"type": "subscribe", "sports": ["soccer"], "markets": ["moneyline"], "main": True}))
async for raw in ws:
msg = json.loads(raw)
if msg["type"] == "ping":
await ws.send('{"type":"pong"}')
elif msg["type"] == "delta":
print(len(msg["changes"]), "changes")
asyncio.run(main())
```
Einen vollständigen Client, der das Quotenbuch live hält und neu verbindet, findest du in der [Python- und Node-Anleitung](/de/guides/pinnacle-odds-websocket-python-node).
## Häufige Fragen
### Was kostet ein Pinnacle-Quoten-WebSocket für Live und Pre-Match?
Stand 9. November 2026 war PinnFeed Builder für 99 €/Monat (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten für Live und Pre-Match gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt odds-api.io Solo + WebSocket auf etwa 98,33 €/Monat.
### Gibt es einen kostenlosen Test?
Ja. Alle bezahlten Pläne starten mit 3 Tagen kostenlos. Du hinterlegst im Checkout eine Karte, die am vierten Tag belastet wird, sofern du nicht kündigst. Der Free-Plan braucht keine Karte.
### Kann ich mit Krypto zahlen?
Ja. Neben der Karte über Stripe kannst du im Dashboard 1, 3 oder 12 Monate in USDC, USDT, SOL oder BTC vorauszahlen. Krypto-Pläne verlängern sich nie automatisch.
### Brauche ich ein Pinnacle-Konto?
Nein. Du brauchst nur einen PinnFeed-API-Key. PinnFeed ist unabhängig und nicht mit Pinnacle verbunden.
---
Source: https://pinnfeed.io/de/compare
# Pinnacle-Quoten-APIs im Vergleich: wer die Preise streamt und was es kostet
Wenn die Pinnacle-Quoten in deinem Code ankommen sollen, sobald sie sich bewegen, zerfällt der Markt in drei Gruppen: Self-Service-APIs mit WebSocket, reine Pinnacle-Reseller, die den Socket als Add-on verkaufen, und Enterprise-Anbieter, die Preise nur im Vertriebsgespräch nennen. Hier sind die veröffentlichten Preise, die wir gefunden haben, mit Links, damit du jede Zahl prüfen kannst.
**Kurze Antwort:** Stand 9. November 2026 war PinnFeed Builder für **99 €/Monat** (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten **für Live und Pre-Match** gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt odds-api.io Solo + WebSocket auf etwa 98,33 €/Monat. Wenn dir Polling reicht, ist The Odds API günstiger als alle anderen, hat aber keinerlei Push-Feed.
## Die Vergleichstabelle
Preise so, wie sie am 9. November 2026 auf der Seite des jeweiligen Anbieters veröffentlicht waren. Die Euro-Umrechnungen nutzen den EZB-Referenzkurs vom 6. November 2026 (1 GBP = 1,1988 €, 1 USD = 0,89566 €) und sind gerundet.
| Anbieter | Pinnacle-Quoten | Echtzeit-Push | Kleinster veröffentlichter Plan mit Push | ≈ € pro Monat | Kostenloser Plan | Quelle |
|---|---|---|---|---|---|---|
| oddssea Prematch | Ja (nur Pinnacle) | WebSocket | Prematch, 59 $/Monat | ≈ 53 € | Ja, verzögertes Pre-Match-REST | [oddssea.dev](https://oddssea.dev/) (geprüft am 9. Nov. 2026) |
| **PinnFeed** | Ja (nur Pinnacle) | WebSocket, normalisierte Deltas | Builder (Live + Pre-Match) | **99 €** (inkl. MwSt., wo anwendbar) | Ja, REST mit 30 s Verzögerung | [Preise](/de/pricing) |
| odds-api.io | Ja (einer deiner Buchmacher) | WebSocket | Solo (2 Buchmacher) + WebSocket, 98 £/Monat | ≈ 117 € monatlich · ≈ 98,33 € bei Jahreszahlung | Nein | [odds-api.io/pricing](https://odds-api.io/pricing) |
| oddspush | Ja (nur Pinnacle) | WebSocket | REST + WebSocket, 138 $ (1 Monat Vorauszahlung) | ≈ 124 € | 7-Tage-Test (REST + WS) | [oddspush.com](https://oddspush.com/#pricing) (geprüft am 9. Nov. 2026) |
| oddssea Live | Ja (nur Pinnacle) | WebSocket | Live, 149 $/Monat | ≈ 133 € | Ja, verzögertes Pre-Match-REST | [oddssea.dev](https://oddssea.dev/) (geprüft am 9. Nov. 2026) |
| pinnwire | Ja (nur Pinnacle) | Raw-WebSocket-Add-on (+ Drops per SSE) | Pro 89 $ + Raw WS 89 $ = 178 $ | ≈ 159 € | Ja, 100 Anfragen/Tag | [pinnwire.com](https://pinnwire.com/), [Docs](https://pinnwire.com/docs.html) (geprüft am 9. Nov. 2026) |
| Reine Pinnacle-Reseller | Ja (nur Pinnacle) | Raw-WebSocket-Add-on | REST-Plan 99 $ + WebSocket-Add-on 99 $ | ≈ 177 € | Ja, 100 Anfragen/Tag | Veröffentlichte Preisseiten der drei geprüften Reseller |
| SportsGameOdds | Pinnacle ab Pro | WebSocket über Pusher (Beta); sendet geänderte Event-ids, die du per REST nachlädst | AllStar oder individueller Plan, Preis auf Anfrage | Nicht veröffentlicht | Ja (Amateur, Updates alle 10 Minuten) | [Streaming-Docs](https://sportsgameodds.com/docs/guides/realtime-streaming-api), [Preise](https://sportsgameodds.com/pricing/) |
| OddsPapi | Ja | WebSocket (v5) | Nur B2B-Plan | Nicht veröffentlicht | Ja, 250 Anfragen/Monat | [WebSocket-Docs](https://oddspapi.io/en/docs/websocket-api) |
| Unabated | Auf der API-Seite nicht genannt; Unabated Line im Concierge-Plan | SSE, kein WebSocket | Concierge, 799 $/Monat (NFL, NBA, MLB, NHL, WNBA; private Nutzung) | ≈ 716 € | 15 Sekunden Verzögerung, für Publisher mit erfüllten Deeplink-Traffic-Zielen | [unabated.com/odds-api](https://unabated.com/odds-api) |
| OpticOdds | Ja (Aggregator) | SSE und RabbitMQ, kein WebSocket | Nur auf Anfrage | Nicht veröffentlicht | Nein | [Preise](https://opticodds.com/pricing), [API-FAQ](https://developer.opticodds.com/docs/api-faq) |
| OddsJam API | Auf der API-Seite nicht genannt | Push-Stream, Protokoll nicht angegeben | Nur auf Anfrage | Nicht veröffentlicht | Kein kostenloser API-Plan veröffentlicht | [oddsjam.com/odds-api](https://oddsjam.com/odds-api) |
| The Odds API | Ja (EU-Region) | **Keiner**, nur REST-Polling | Kein Push-Plan; Polling ab 30 $/Monat | ≈ 27 € (Polling) | Ja, 500 Credits/Monat | [the-odds-api.com](https://the-odds-api.com/) |
## So liest du die Tabelle
- **Push gegen Polling.** Ein WebSocket liefert jede Preisänderung genau einmal, wenn sie passiert. Wer einen REST-Endpoint alle N Sekunden pollt, verpasst Zwischenbewegungen und verbraucht Kontingent für Preise, die sich nicht geändert haben. Für Steam-Erkennung, Live-Modelle und alles Zeitkritische zählt Push. Siehe [warum Push Polling schlägt](/odds-websocket-api) (auf Englisch).
- **Live + Pre-Match gegen nur Pre-Match.** Mehrere spezialisierte Feeds bieten einen reinen Pre-Match-WebSocket günstiger an. Die Aussage auf dieser Seite gilt nur für Pläne, die Pinnacle-Quoten **für Live und Pre-Match** streamen. oddssea Prematch ist mit 59 $/Monat günstiger, wenn du keine Live-Quoten brauchst.
- **Nur Pinnacle gegen viele Buchmacher.** PinnFeed liefert nur Pinnacle, den schärfsten Markt und den üblichen Referenzpreis. Wenn du zusätzlich Quoten von Soft-Buchmachern im selben Feed brauchst, passt ein Aggregator wie odds-api.io oder SportsGameOdds besser, und du zahlst pro zusätzlichem Buchmacher.
- **Was im Preis steckt.** Builder bündelt den WebSocket mit REST bei 10 Anfragen pro Sekunde, allen 13 Sportarten, Alternativlinien, Props und Langzeitwetten, fairen Quoten für jeden Markt und der Historie der Schlussquoten. Reine Pinnacle-Reseller verkaufen den Socket als 99-$-Add-on zu einem REST-Plan, deshalb liegt die Summe bei etwa 177 €. Auch pinnwire berechnet den Raw-WebSocket ab Pro als Add-on für +89 $.
- **Anbieter nur auf Anfrage.** OpticOdds, die OddsJam API und die B2B-Stufen anderer Anbieter veröffentlichen keine Preise. Artikel Dritter nennen Zahlen, aber wir lassen sie weg, weil die Anbieter sie nicht veröffentlicht haben.
## Eine Seite pro Anbieter
Jeder Anbieter hat eine eigene Seite (auf Englisch) mit Fazit, datierter Preistabelle und der Frage, wann er statt PinnFeed die bessere Wahl ist: Starte bei [Alternativen zur Pinnacle-Quoten-API](/alternatives) oder geh direkt zu [oddssea](/oddssea-alternative), [odds-api.io](/odds-api-io-alternative), [oddspush](/oddspush-alternative), [pinnwire](/pinnwire-alternative), [The Odds API](/the-odds-api-alternative), [OpticOdds](/opticodds-alternative), [OddsJam](/oddsjam-alternative), [SportsDataIO](/sportsdataio-alternative) oder [Sportmonks](/sportmonks-alternative).
## Was wir nicht behaupten
- Wir behaupten keine geringere Latenz als irgendein bestimmter Anbieter; einen direkten Vergleichstest haben wir nicht gemacht.
- Wir behaupten nicht, günstiger als The Odds API zu sein; die kostet weniger, pusht aber keine Daten.
- Wir behaupten nicht, günstiger als ein **reiner Pre-Match**-WebSocket zu sein (oddssea Prematch, 59 $/Monat, Stand 9. November 2026).
- „Niedrigster“ heißt hier: der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir am 9. November 2026 für einen Echtzeit-WebSocket mit Pinnacle-Quoten **für Live und Pre-Match** finden konnten. Preise ändern sich. Wenn du in diesem Rahmen einen günstigeren veröffentlichten Plan siehst, schreib uns, und wir aktualisieren die Seite.
## Häufige Fragen
### Was ist der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung für einen Pinnacle-Quoten-WebSocket für Live und Pre-Match?
Stand 9. November 2026 war PinnFeed Builder für 99 €/Monat (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten für Live und Pre-Match gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt der Plan Solo + WebSocket von odds-api.io auf etwa 98,33 € pro Monat, wenn du das Jahr im Voraus zahlst.
### Gibt es einen kostenlosen Pinnacle-Quoten-WebSocket?
Wir haben keinen gefunden. Kostenlose Pläne mit Pinnacle-Preisen sind reines REST: der Free-Plan von PinnFeed hat 30 Sekunden Verzögerung, The Odds API gibt 500 Credits pro Monat und OddsPapi 250 Anfragen pro Monat.
### Hat The Odds API einen WebSocket?
Nein. The Odds API ist reines REST; um Änderungen zu sehen, musst du pollen. Die Pläne beginnen bei 30 $ pro Monat.
### Hat OpticOdds einen WebSocket?
Nein. Laut der eigenen API-FAQ bietet OpticOdds weder Webhooks noch WebSockets an und streamt per Server-Sent Events. Preise gibt es nur auf Anfrage.
### Ist PinnFeed die offizielle Pinnacle-API?
Nein. Pinnacle hat seine öffentliche API im Juli 2025 geschlossen. PinnFeed ist ein unabhängiger Dienst, nicht mit Pinnacle verbunden, der beobachtete Pinnacle-Preise für Softwareentwicklung und Forschung weitergibt.
---
Source: https://pinnfeed.io/de/faq
# Häufige Fragen zu PinnFeed
Direkte Antworten zu PinnFeed, der Pinnacle-Quoten-API in Echtzeit. PinnFeed (pinnfeed.io, mit doppeltem n) ist eine Pinnacle-Quoten-API, nicht die Pinterest-App PinFeed. Es gibt einen Free-Tarif (ohne Karte, REST mit 30 s Verzögerung, 2 Sportarten) und eine kostenlose Testphase von 3 Tagen bei den bezahlten Tarifen (Karte erforderlich). Etwas fehlt? Schreib an support@pinnfeed.io.
## Fragen zu Produkt und Daten
### Was ist PinnFeed?
PinnFeed (pinnfeed.io, mit doppeltem n) ist eine Entwickler-API für Pinnacle-Sportwettenquoten in Echtzeit, nicht die Pinterest-App PinFeed. Sie liefert Live- und Pre-Match-Preise über einen einzigen WebSocket mit serverseitigen Filtern und Delta-Updates, dazu REST-Snapshots, faire Quoten ohne Marge, die Historie der Schlussquoten und einen gehosteten MCP-Server für KI-Assistenten.
### Ist PinnFeed die offizielle Pinnacle-API?
Nein. Pinnacle hat seine öffentliche API im Juli 2025 geschlossen. PinnFeed ist ein unabhängiger Dienst, nicht mit Pinnacle verbunden, und du brauchst kein Pinnacle-Konto.
### Welche Sportarten und Märkte sind abgedeckt?
Dreizehn Sportarten: Fußball, Tennis, Basketball, Eishockey, American Football, Baseball, Rugby, MMA, Boxen, Volleyball und Handball, E-Sport, Golf und Cricket. Die Märkte sind Siegwette (Moneyline), Handicap, Über/Unter und Team-Totals jeder Periode, dazu ab Builder Alternativlinien, Props und Langzeitwetten.
### Was enthält jeder Markt?
Dezimal- und amerikanische Quoten, die Linie, Pinnacles Maximaleinsatz, die Buchmachermarge sowie die faire Quote ohne Marge und die faire Wahrscheinlichkeit jedes Ausgangs.
### Wie aktuell sind die Daten?
Die bezahlten Pläne laufen in Echtzeit: Der WebSocket pusht jede Änderung, sobald sie eingeht. Der kostenlose Plan ist um 30 Sekunden verzögert.
### Kann ich PinnFeed mit ChatGPT oder Claude nutzen?
Ja. PinnFeed hostet unter https://pinnfeed.io/mcp einen MCP-Server, der mit Claude, Claude Code, dem Entwicklermodus von ChatGPT, Cursor, VS Code Copilot und Codex funktioniert. Siehe die MCP-Anleitung.
### Sind die Inhalte nur für Erwachsene?
Ja. Die Quotendaten und die Anleitungen sind Bildungsmaterial für Erwachsene ab 18 Jahren. Nichts davon ist ein Tipp, eine sichere Wette oder ein Gewinnversprechen.
## Fragen zu Preisen und Abrechnung
### Was kostet PinnFeed?
Free 0 € (REST, 30 Sekunden Verzögerung); Hobby 29 €/Monat (REST in Echtzeit, kein WebSocket); Builder 99 €/Monat (der WebSocket-Plan); Pro 199 €/Monat; Enterprise auf Anfrage. Die Preise enthalten die MwSt., wo anwendbar.
### Welcher Plan enthält den WebSocket?
Builder (99 €/Monat) und höher. Free- und Hobby-Keys sind reines REST.
### Gibt es einen kostenlosen Test?
Ja, 3 Tage kostenlos für alle bezahlten Pläne. Die Karte wird am vierten Tag belastet, sofern du nicht kündigst. Ein Test pro Kunde.
### Ist PinnFeed bei monatlicher Abrechnung der günstigste Pinnacle-WebSocket für Live + Pre-Match?
Stand 9. November 2026 war PinnFeed Builder für 99 €/Monat (inkl. MwSt.) der niedrigste veröffentlichte Preis bei monatlicher oder jährlicher Abrechnung, den wir für einen Echtzeit-WebSocket mit Pinnacle-Quoten **für Live und Pre-Match** gefunden haben. Ein reiner Pre-Match-WebSocket wird günstiger angeboten (oddssea Prematch, 59 $/Monat). Bei jährlicher Abrechnung kommt odds-api.io Solo + WebSocket auf etwa 98,33 €/Monat. Der [Vergleich](/de/compare) verlinkt alle Quellen.
### Kann ich mit Krypto zahlen?
Ja. Du kannst im Dashboard 1, 3 oder 12 Monate in USDC, USDT, SOL oder BTC vorauszahlen oder per Karte über Stripe zahlen.
### Enthalten die Preise MwSt., und kann mein Unternehmen eine USt-IdNr. angeben?
Ja. Die Preise sind in Euro und enthalten die MwSt., wo anwendbar: Die genannten EUR-Preise enthalten die MwSt., wo anwendbar, und Stripe ermittelt den MwSt-Anteil im Checkout anhand deiner Rechnungsadresse. Dieser Anteil kann 0 sein, bei Übergang der Steuerschuldnerschaft oder wenn keine MwSt. anfällt. Unternehmen können im Checkout ihre USt-IdNr. angeben.
### Wie kündige ich?
Im Dashboard: Plan & billing → Manage billing → Cancel. Der Zugang bleibt bis zum Ende des bezahlten Zeitraums bestehen.
---
Source: https://pinnfeed.io/de/answers/nfl-player-props-odds-api-pinnacle
# NFL-Spieler-Props-API mit Pinnacle-Preisen
**Antwort:** Pinnacle veröffentlicht NFL Player Props als **special**-Events unter `american-football`. Auf Builder/Pro liefert `/v1/odds?sport=american-football` sie mit `parentId` zum Spiel. Free/Hobby sind main-only.
## Beispiel
```python
import os, requests
from collections import defaultdict
H = {"x-api-key": os.environ["PINNFEED_KEY"]} # ps_live_...
# 1) find the NFL league id once (college football is a different league)
ev = requests.get("https://pinnfeed.io/v1/events", headers=H, timeout=10,
params={"sport": "american-football", "q": "nfl", "limit": 200}).json()["events"]
print({(e["league"]["id"], e["league"]["name"]) for e in ev if e["league"]})
LEAGUE = int(input("NFL league id: "))
# 2) games and props together (no main=true: that would drop the specials)
data = requests.get("https://pinnfeed.io/v1/odds", headers=H, timeout=15,
params={"sport": "american-football", "league": LEAGUE, "limit": 500}).json()["events"]
games = {e["id"]: e for e in data if not e.get("special")}
props = defaultdict(list)
for e in data:
if e.get("special") and e.get("parentId") in games:
props[e["parentId"]].append(e)
for gid, items in props.items():
g = games[gid]
print(f'{g["away"]} @ {g["home"]} ({len(items)} props)')
for p in items[:10]:
for m in p["markets"]:
line = " | ".join(f'{o["name"]} {o["decimal"]} (fair {o.get("fair")})' for o in m["outcomes"])
print(" ", p["special"]["description"], m["type"], m.get("line"), line)
```
```json
{ "type": "subscribe", "sports": ["american-football"], "leagues": [LEAGUE_ID], "specials": true }
```
Verwandt: [Specials](/de/answers/pinnacle-specials-props-odds-api), [NFL-API](/de/answers/pinnacle-nfl-american-football-odds-api).
## CTA
[Builder](/de/pricing#plan-builder) (99 €/Monat). 3 Tage Test; Karte nötig. REST gratis: [Signup](/signup).
## Häufige Fragen
### Enthält Free NFL-Props?
Nein — Builder.
### Bildungsinhalt für Erwachsene?
Ja (18+).
*Bildungsinhalt für Erwachsene (18+). Keine Tipps, kein Gewinnversprechen. In Deutschland nur bei Anbietern auf der GGL-Whitelist wetten.*
---
Source: https://pinnfeed.io/de/vibe-coding
# Mit PinnFeed und KI bauen
**Antwort:** Free-Key unter [signup](/signup), `PINNFEED_KEY`, Prompts und [llms-api.txt](/llms-api.txt). Auth `x-api-key`. WS = Builder. 18+.
```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/odds?sport=soccer&main=true&limit=3"
```
Kontext: [llms-api.txt](/llms-api.txt) · [AGENTS.md](/AGENTS.md) · [Postman](/postman/pinnfeed.postman_collection.json) · [docs/mcp](/docs/mcp).
## Test-CTA
[Builder](/de/pricing#plan-builder) (€99/Monat). 3-Tage-Test. [signup](/signup).
## Häufige Fragen
### Brauche ich Builder?
Nur für `/v1/stream` und Closing.
### Endpunkte erfinden?
Nein — OpenAPI + llms-api.txt.
### Bildungsinhalt 18+?
Ja.
---
Source: https://pinnfeed.io/de/quickstart
# Quickstart — Key zur ersten Quote
**Antwort:** [signup](/signup) → `ps_live_...` → `export PINNFEED_KEY` → curl `/v1/odds`. Dann Python, Node, Sheets. WS = Builder.
```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/odds?sport=soccer&main=true&limit=5"
```
Sheets: Apps Script. [vibe coding](/de/vibe-coding).
## Test-CTA
[signup](/signup) · [pricing](/de/pricing#plan-builder).
## Häufige Fragen
### Vs /docs?
60 s hier; voll in /docs.
### Key in Zelle?
Nein.
### 18+?
Ja.
---
Source: https://pinnfeed.io/de/answers/football-odds-feed-pinnacle
# Fußball-Quoten-Feed von Pinnacle
**Antwort:** Der Feed `sport=soccer` von PinnFeed liefert Pinnacles Fußballmärkte: Moneyline (1X2), Spread (asiatisches Handicap), Tore-Totals und Team-Totals, für jede Periode, die Pinnacle anbietet, vor dem Spiel und live. Fragen Sie `GET /v1/odds?sport=soccer` in jedem Tarif ab, oder erhalten Sie jede Änderung per WebSocket mit Builder (99 €/Monat).
## REST
```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
"https://pinnfeed.io/v1/odds?sport=soccer&market=moneyline,spread,total&main=true&limit=50"
```
Filtern Sie nach `league`-ID (Ligen aus `GET /v1/events?sport=soccer`), `live=true` oder `live=prematch`, oder mit `q=` nach einem Teamnamen (z. B. `q=bayern`).
## WebSocket (Builder)
```json
{ "type": "subscribe", "sports": ["soccer"], "markets": ["moneyline", "spread", "total"], "main": true }
```
Sie erhalten `subscribed`, dann `snapshot`-Frames und danach `delta`-Frames, sobald sich Preise bewegen. Der Server sendet alle 20 Sekunden ein `ping`; antworten Sie mit `{"type":"pong"}`. Clients: [Python](/de/answers/pinnacle-odds-websocket-python-example), [Node mit Reconnect](/de/answers/pinnacle-odds-websocket-nodejs-reconnect).
## Seiten nach Markt
| Markt | Antwort |
|---|---|
| 1X2 / Moneyline | [Fußball-Moneyline](/de/answers/football-odds-feed-pinnacle) |
| Asiatisches Handicap | [Fußball-Spread](/de/answers/football-odds-feed-pinnacle), [asiatisches Handicap](/de/answers/football-odds-feed-pinnacle) |
| Tore-Totals | [Fußball-Totals](/de/answers/football-odds-feed-pinnacle) |
| Ecken | [Fußball-Ecken](/de/answers/pinnacle-soccer-corners-odds-api) |
| Eröffnung und Schluss | [Eröffnungs- und Schlussquoten](/de/answers/pinnacle-opening-closing-odds-football-api) |
## Tarife
Free: 30 Sekunden Verzögerung, 2 Sportarten nach Wahl, Hauptmärkte. Hobby (29 €/Monat): REST in Echtzeit. [Builder](/de/pricing#plan-builder): WebSocket, alle Märkte, Props und Schlussquoten-Historie. Bezahlte Tarife: 3 Tage Testphase; eine Karte ist erforderlich und wird nach Tag 3 belastet, sofern Sie nicht kündigen.
*Bildungsinhalt für Erwachsene (18+). Keine Tipps, kein garantierter Gewinn. In Deutschland dürfen nur behördlich erlaubte Anbieter Sportwetten anbieten (Whitelist der GGL).*
## Häufige Fragen
### Enthält der Feed Spielstände?
Live-Events haben `score`, `clock` und `status`, soweit Pinnacle sie liefert. PinnFeed ist ein Quoten-Feed, kein Statistikanbieter: keine Aufstellungen, keine Spielerdaten.
### Welche Ligen sind abgedeckt?
Alles, was Pinnacle anbietet. Aktuelle Ligen und Events liefert `GET /v1/events?sport=soccer`.
### Andere Buchmacher?
Nein. PinnFeed liefert nur Pinnacle. Siehe [Multi-Book vs. nur Pinnacle](/de/answers/multi-book-odds-api-vs-pinnacle-only).
---
Source: https://pinnfeed.io/de/answers
# Antworten auf konkrete Fragen zur Pinnacle-Quoten-API
Jede Seite beantwortet eine konkrete Frage: zuerst die Antwort, dann Code, der gegen die echte PinnFeed-API läuft, und zum Schluss häufige Fragen. Weitere Seiten finden Sie in den [englischen Antworten](/answers); vollständige Anleitungen in den [Guides](/de/guides).
## Seiten auf Deutsch
- [+EV-API mit fairen No-Vig-Quoten](/de/answers/ev-betting-api-no-vig)
- [+EV-Scanner per Vibe-Coding (Bildung)](/de/answers/vibe-coding-ev-scanner)
- [API alternativer Pinnacle-Linien](/de/answers/pinnacle-alternate-lines-api)
- [API für faire Quoten ohne Marge (No-Vig)](/de/answers/no-vig-fair-odds-api)
- [Arbitrage vs. Value Betting mit Sharp-API](/de/answers/arbitrage-vs-value-betting-api)
- [Arbitrage-Rechner mit Pinnacle-Quoten](/de/answers/arbitrage-calculator-pinnacle-odds)
- [Architektur eines Wett-Bots mit Pinnacle](/de/answers/sports-betting-bot-architecture)
- [Authentifizierung der Pinnacle-Quoten-API](/de/answers/pinnacle-odds-api-authentication)
- [Backtest gegen Pinnacle-Closings](/de/answers/pinnacle-odds-api-backtesting-clv)
- [Sportsbook API integration (Pinnacle feed vs book APIs)](/answers/sportsbook-api-integration-pinnacle)
- [Betfair Exchange API vs PinnFeed](/pinnfeed-vs-betfair-exchange-api)
- [Betfair Exchange API-Preis — £499](/betfair-exchange-api-alternative)
- [Fußball-Odds-Feed (inkl. Liga-Filter)](/de/answers/football-odds-feed-pinnacle)
- [C#-/.NET-Client für Pinnacle-Quoten](/de/answers/pinnacle-odds-websocket-csharp)
- [ChatGPT-Prompt für Quoten-API](/de/answers/chatgpt-odds-api-prompt)
- [Claude-MCP für Pinnacle-Quoten](/de/answers/claude-mcp-sports-odds)
- [Filter odds by league id (WNBA, EuroLeague, college)](/answers/pinnacle-odds-by-league-id)
- [Crypto-Zahlung für die PinnFeed-Quoten-API](/de/answers/pinnacle-odds-api-crypto-payment)
- [curl-Rezepte für die Pinnacle-Odds-API](/de/answers/pinnacle-odds-curl-openapi-recipes)
- [Discord-Bot mit Pinnacle-Quoten](/de/answers/discord-picks-bot-pinnacle-odds)
- [Dropping-Odds-API — /v1/drops und Steam](/de/answers/dropping-odds-api)
- [E-Mail-Drop-Alert in Google Sheets](/de/answers/google-sheets-odds-drop-email-alert)
- [Excel-Power-Query-Guide Pinnacle](/de/answers/pinnacle-odds-excel-power-query-guide)
- [FairProb-EV-Screen in Python](/de/answers/pinnacle-odds-python-fairprob-ev-screen)
- [FastAPI-Proxy für Pinnacle-Quoten](/de/answers/pinnacle-odds-fastapi-proxy)
- [Fehlercodes der Pinnacle-Quoten-API](/de/answers/pinnacle-odds-api-error-codes)
- [Go-Client für den Pinnacle-Quoten-WebSocket](/de/answers/pinnacle-odds-websocket-golang)
- [Hat The Odds API einen WebSocket?](/de/answers/the-odds-api-websocket)
- [Historical odds via Pinnacle closings](/answers/historical-betting-odds-pinnacle-closing)
- [Implizite Prob. über fairProb](/de/answers/pinnacle-odds-implied-probability-api)
- [Kelly-Kriterium mit fairen Pinnacle-Quoten](/de/answers/kelly-criterion-pinnacle-fair-odds)
- [Kompression des Pinnacle-Quoten-WebSockets](/de/answers/pinnacle-odds-websocket-compression)
- [Kostenlose Quoten-API: was free enthält](/de/answers/free-odds-api)
- [Line Shopping gegen den Pinnacle-Preis (API)](/de/answers/line-shopping-vs-pinnacle)
- [Live-Odds-XML-Feed — JSON-Alternative](/de/answers/live-odds-xml-feed-to-json)
- [Live-Push vs REST-Polling](/de/answers/pinnacle-live-odds-push-vs-polling)
- [LoL- und Dota-2-Quoten-API (Pinnacle)](/de/answers/lol-dota2-odds-api-pinnacle)
- [Margenfrei-Rechner in Excel oder Google Sheets](/de/answers/no-vig-calculator-excel-sheets)
- [MCP-Prompts für Pinnacle-Quoten](/de/answers/pinnacle-odds-mcp-prompts-cookbook)
- [MLB-CLV-Tracker über Pinnacle-API](/de/answers/mlb-closing-line-value-tracker-api)
- [Multi-Book-API vs nur Pinnacle](/de/answers/multi-book-odds-api-vs-pinnacle-only)
- [NFL- und NBA-Player-Props](/de/answers/nfl-player-props-odds-api-pinnacle)
- [NBA Moneyline, Spreads und Totals](/de/answers/pinnacle-nba-moneyline-odds-api)
- [NFL-Quoten-API von Pinnacle](/de/answers/pinnacle-nfl-american-football-odds-api)
- [Nur Prematch vs Live+Prematch-WS](/de/answers/pinnacle-prematch-vs-live-websocket)
- [odds-api.io jährlich vs Builder](/de/answers/odds-api-io-annual-vs-pinnfeed-builder)
- [odds-api.io vs PinnFeed — €118 vs €99](/pinnfeed-vs-odds-api-io)
- [OddsJam vs PinnFeed — Angebot vs €99](/pinnfeed-vs-oddsjam)
- [OddsJam-API: Angebot vs Self-Serve](/de/answers/oddsjam-api-quote-vs-self-serve)
- [OpticOdds vs PinnFeed — SSE vs WS](/pinnfeed-vs-opticodds)
- [Ping/Pong-Heartbeat des Pinnacle-WebSockets](/de/answers/pinnacle-odds-websocket-ping-pong)
- [Pinnacle Baseball- / MLB-Quoten-API](/de/answers/pinnacle-baseball-mlb-odds-api)
- [Pinnacle Baseball-Run-Line-Quoten-API](/answers/historical-mlb-odds-pinnacle)
- [Pinnacle CS:GO-/CS2-Odds-API](/de/answers/pinnacle-csgo-odds-api)
- [Pinnacle Fußball: Eröffnungs- und Schlussquoten](/de/answers/pinnacle-opening-closing-odds-football-api)
- [Pinnacle MMA- / UFC-Quoten-API](/de/answers/pinnacle-mma-ufc-odds-api)
- [Pinnacle NHL- / Eishockey-Quoten-API](/de/answers/pinnacle-nhl-hockey-odds-api)
- [Pinnacle odds API](/pinnacle-odds-api)
- [Pinnacle Volleyball- & Handball-API](/de/answers/pinnacle-volleyball-handball-odds-api)
- [Pinnacle-API geschlossen: welche Optionen?](/de/answers/pinnacle-api-access-closed)
- [Pinnacle-API — Self-Serve mit PinnFeed](/de/answers/pinnacle-api-self-serve)
- [Pinnacle-Boxing-Quoten-API](/de/answers/pinnacle-boxing-odds-api)
- [Pinnacle-Closing-API für CLV](/de/answers/pinnacle-closing-line-api-clv)
- [Pinnacle-Closing-Lines in Python (CLV)](/de/answers/pinnacle-odds-python-closing-lines-clv)
- [Pinnacle-Closings in DuckDB und Parquet](/de/answers/pinnacle-closing-odds-duckdb-parquet)
- [Pinnacle-Closings — europäischer Fußball](/de/answers/pinnacle-closing-lines-european-football-api)
- [Pinnacle-Esports-Quoten-API](/de/answers/pinnacle-esports-odds-api)
- [Pinnacle-Fußball-Ecken-Quoten-API](/de/answers/pinnacle-soccer-corners-odds-api)
- [Pinnacle-Golf-Quoten-API](/de/answers/pinnacle-golf-odds-api)
- [Pinnacle-Linienbewegungs-API](/de/answers/pinnacle-line-movement-api)
- [Pinnacle-Live-Quoten-API](/de/answers/pinnacle-live-odds-api)
- [Pinnacle-Marge (Overround) pro Markt per API](/de/answers/pinnacle-margin-overround-api)
- [Pinnacle-maxStake-API für jeden Markt](/de/answers/pinnacle-max-stake-api)
- [Pinnacle-Odds in Python paginieren (REST)](/de/answers/pinnacle-odds-python-events-odds-pagination)
- [Pinnacle-Odds-API Free: 30s Delay](/de/answers/pinnacle-odds-api-free-tier-delay)
- [Pinnacle-Odds-Client in Python bootstrappen](/de/answers/pinnacle-odds-python-account-bootstrap)
- [Pinnacle-Preisdrops in Node.js pollen](/de/answers/pinnacle-odds-nodejs-drops-poller)
- [Pinnacle-Quoten auf einem Cloudflare Worker](/de/answers/pinnacle-odds-cloudflare-worker)
- [Pinnacle-Quoten für ein Team per Name (API)](/de/answers/pinnacle-odds-by-team-name)
- [Pinnacle-Quoten im Browser-JS (CORS)](/de/answers/pinnacle-odds-browser-javascript-cors)
- [Pinnacle-Quoten in ChatGPT und Claude per MCP](/de/answers/pinnacle-odds-chatgpt-mcp)
- [Pinnacle-Quoten in einem pandas-DataFrame](/de/answers/pinnacle-odds-pandas-dataframe)
- [Pinnacle-Quoten in Excel Power Query](/de/answers/pinnacle-odds-excel-power-query)
- [Pinnacle-Quoten in n8n (HTTP Request)](/de/answers/pinnacle-odds-api-n8n)
- [Pinnacle-Quoten in Postgres speichern](/de/answers/pinnacle-odds-postgres-storage)
- [Pinnacle-Quoten in Python (REST)](/de/answers/pinnacle-odds-python-rest)
- [Pinnacle-Quoten in Sheets ohne Code](/de/answers/no-code-odds-google-sheets)
- [Pinnacle-Quoten in Supabase (Edge Function)](/de/answers/pinnacle-odds-supabase-edge-function)
- [Pinnacle-Quoten kommerziell nutzen?](/de/answers/pinnacle-odds-api-commercial-use)
- [Pinnacle-Quoten mit IMPORTDATA](/de/answers/pinnacle-odds-google-sheets-importdata)
- [Pinnacle-Quoten ohne Scraping](/de/answers/pinnacle-odds-without-scraping)
- [Pinnacle-Quoten-API für ein Startup-MVP](/de/answers/pinnacle-odds-api-startup-mvp)
- [Pinnacle-Quoten-API für Sheets und Excel](/de/answers/pinnacle-odds-api-google-sheets-excel)
- [Pinnacle-Quoten-API in Power BI](/de/answers/pinnacle-odds-api-power-bi)
- [Pinnacle-Quoten-API in R mit httr2](/de/answers/pinnacle-odds-api-r-httr2)
- [Pinnacle-Quoten-API kostenlos testen](/de/answers/pinnacle-odds-api-free-trial)
- [Pinnacle-Quoten-WebSocket in Kotlin (OkHttp)](/de/answers/pinnacle-odds-websocket-kotlin)
- [Pinnacle-Quoten-WebSocket in Node.js](/de/answers/pinnacle-odds-websocket-nodejs-reconnect)
- [Pinnacle-Quoten-WebSocket: Python-Beispiel](/de/answers/pinnacle-odds-websocket-python-example)
- [Pinnacle-Quoten: historisch oder live](/de/answers/pinnacle-odds-historical-vs-live)
- [Pinnacle-Snapshot/Deltas in einer Node-Map anwenden](/de/answers/pinnacle-odds-node-snapshot-delta-map)
- [Pinnacle-Specials- und Props-API](/de/answers/pinnacle-specials-props-odds-api)
- [Pinnacle-Steam nach Telegram](/de/answers/pinnacle-steam-telegram-alert)
- [Pinnacle-Tennisquoten-API](/de/answers/pinnacle-tennis-odds-api)
- [Pinnacle-WebSocket: Snapshot und Delta](/de/answers/pinnacle-odds-websocket-snapshot-delta)
- [Pinnacle-WS: stale Preise & Reconnect](/de/answers/pinnacle-websocket-stale-price-reconnect)
- [PinnFeed Builder-Plan — was enthalten ist](/de/answers/pinnacle-odds-api-builder-whats-included)
- [PinnFeed kündigen oder Erstattung erhalten](/de/answers/pinnacle-odds-api-cancel-refund)
- [PinnFeed Sport-IDs und Slugs (13)](/de/answers/pinnacle-odds-api-sport-ids)
- [PinnFeed-API-Schlüssel rotieren oder widerrufen](/de/answers/pinnacle-odds-api-key-rotation)
- [PinnFeed-MCP-Tools-Referenz (Odds)](/de/answers/pinnacle-odds-mcp-tools-reference)
- [PinnFeed: jährliche und quartalsweise Abrechnung](/de/answers/pinnfeed-annual-quarterly-billing)
- [Quoten-API-Latenz: selbst messen](/de/answers/pinnacle-odds-api-latency-honesty)
- [Quoten-API-Preise: pro Anfrage oder pauschal](/de/answers/odds-api-pricing-per-request-vs-flat)
- [Quoten-WebSocket mit wscat testen](/de/answers/pinnacle-odds-websocket-wscat)
- [Ratenlimits der Pinnacle-Quoten-API](/de/answers/pinnacle-odds-api-rate-limits)
- [Raw-Pinnacle-Frames (Pro)](/de/answers/pinnacle-odds-websocket-raw-frames)
- [Rust-Client für den Pinnacle-Quoten-WebSocket](/de/answers/pinnacle-odds-websocket-rust)
- [SportsDataIO vs PinnFeed](/pinnfeed-vs-sportsdataio)
- [SSE-Drops vs Pinnacle-WebSocket](/de/answers/pinnacle-odds-sse-vs-websocket)
- [Steam Chasing mit Pinnacle-Drop-Alerts](/de/answers/steam-chasing-pinnacle-alerts)
- [Steam-Moves in Python (WebSocket)](/de/answers/steam-move-detection-python-websocket)
- [Steam-Moves mit der Pinnacle-API erkennen](/de/answers/detect-steam-moves-pinnacle-api)
- [Telegram-Picks-Bot auf Pinnacle-Quoten](/de/answers/telegram-picks-bot-pinnacle)
- [The Odds API vs PinnFeed — Poll vs Push](/pinnfeed-vs-the-odds-api)
- [The Odds API-Polling vs PinnFeed-Push](/de/answers/the-odds-api-polling-vs-pinnfeed-push)
- [TypeScript-WebSocket-Client Pinnacle](/de/answers/pinnacle-odds-websocket-typescript)
- [Webhook vs WebSocket für Pinnacle-Quoten](/de/answers/pinnacle-odds-webhook-vs-websocket)
- [Wett-Bot mit Cursor und PinnFeed](/de/answers/build-betting-bot-with-cursor)
- [Wett-Tracker-Tabelle mit CLV (Pinnacle)](/de/answers/bet-tracker-spreadsheet-clv)
- [Wettquoten-API: so wählen Sie 2026](/de/answers/betting-odds-api)
- [Zeitgesteuerter Pinnacle-Odds-Refresh in Sheets](/de/answers/pinnacle-odds-sheets-time-driven-trigger)
*Bildungsinhalt für Erwachsene (18+). Keine Tipps, kein Gewinnversprechen. In Deutschland nur bei Anbietern auf der GGL-Whitelist wetten.*
## Häufige Fragen
### Warum gibt es weniger Seiten als auf Englisch?
Wir übersetzen zuerst die meistgesuchten Fragen. Der Rest steht in den [englischen Antworten](/answers), mit demselben Code.
### Wo fange ich an?
Mit dem [Schnellstart](/de/quickstart) und einem [kostenlosen Schlüssel](/signup); danach [Self-Service-Zugang](/de/answers/pinnacle-api-self-serve).
---
Source: https://pinnfeed.io/de/answers/pinnacle-nba-moneyline-odds-api
# NBA-Moneyline-Quoten von Pinnacle in Echtzeit
**Antwort:** der PinnFeed-Slug für die NBA (und übrigen Basketball) ist **`basketball`**. Frage auf Free oder Hobby `GET /v1/odds?sport=basketball&market=moneyline&main=true` ab, oder abonniere auf Builder (99 €/Monat) den WebSocket mit `"sports":["basketball"],"markets":["moneyline"],"main":true`. Einen Slug `nba` gibt es nicht: filtere im Client nach `league.name`.
## REST-Snapshot (funktioniert auf Free mit 30 s Verzögerung)
```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
"https://pinnfeed.io/v1/odds?sport=basketball&market=moneyline&main=true&live=true&limit=20"
```
Jedes Event enthält `league`, `home`, `away` und Märkte, deren Ausgänge `decimal`, `american`, `fair` und `fairProb` haben.
## WebSocket-Abo (Builder)
```javascript
// Example Node fragment — needs Builder key
const ws = new WebSocket('wss://pinnfeed.io/v1/stream', {
headers: { 'x-api-key': process.env.PINNFEED_KEY },
});
ws.on('open', () => ws.send(JSON.stringify({
type: 'subscribe',
sports: ['basketball'],
markets: ['moneyline'],
main: true,
live: true,
specials: false,
})));
ws.on('message', (buf) => {
const msg = JSON.parse(buf);
if (msg.type === 'ping') ws.send(JSON.stringify({ type: 'pong' }));
// filter NBA: if (event.league?.name?.includes('NBA')) ...
});
```
Sportarten: [Schema](/docs/schema). Vollständiger Client: [Python- und Node-Guide](/de/guides/pinnacle-odds-websocket-python-node). Siehe auch: [historische NBA-Quoten](/answers/historical-betting-odds-pinnacle-closing).
## Tarife
Live-Push: [Builder](/de/pricing#plan-builder) (99 €/Monat). Testphase 3 Tage; eine Karte ist nötig und wird nach Tag 3 belastet, wenn du nicht kündigst. Kostenloses REST mit Verzögerung: [Registrierung](/signup).
*Bildungsinhalt für Erwachsene (18+). Keine Tipps, kein Gewinnversprechen. In Deutschland nur bei Anbietern auf der GGL-Whitelist wetten.*
## Häufige Fragen
### Ist der Slug `nba` oder `basketball`?
`basketball`. Die 13 Sportarten von PinnFeed nutzen die Slugs aus der Doku; NBA-Spiele kommen in den Basketball-Ligen.
### Kann Free NBA-Moneylines live empfangen?
Free kann `/v1/odds` mit 30 s Verzögerung und 2 Sportarten **abfragen**. Live-Push per WebSocket beginnt bei Builder.
---
Source: https://pinnfeed.io/de/guides/pinnacle-odds-websocket-python-node
# Pinnacle-Quoten in Echtzeit per WebSocket mit Python und Node
In dieser Anleitung baust du einen Client, der eine Live-Kopie der Pinnacle-Preise im Speicher hält: Er verbindet sich, abonniert, lädt den Snapshot, wendet jedes Delta an, beantwortet Heartbeats und verbindet sich selbst neu. Die anderen Anleitungen (Steam-Alerts, Value Betting, der Telegram-Bot) bauen darauf auf.
Du brauchst einen PinnFeed-Key im **Builder**-Plan (der WebSocket-Plan, 99 €/Monat, 3 Tage kostenlos). Mit einem Free- oder Hobby-Key kannst du die REST-Beispiele aus der [Dokumentation](/docs/rest) (auf Englisch) nutzen.
## Schritt 1 — Key holen und in der Umgebung ablegen
Leg im [Dashboard](/dashboard) einen Key an und exportiere ihn, damit er nie in deinem Code landet:
```bash
export PINNFEED_KEY="ps_live_..."
```
## Schritt 2 — Die Frames verstehen
Nach dem Verbinden und dem Senden von `subscribe` schickt der Server:
1. `subscribed` und danach einen **Snapshot** in Teilen (`part`, `parts`, `final`) mit allen Events und Märkten, die zu deinen Filtern passen;
2. **Delta**-Frames, jeder mit einer Liste `changes`: `upsert` enthält das vollständige neue Objekt, `remove` nur dessen id;
3. alle 20 Sekunden einen **Ping**. Antworte mit `{"type":"pong"}`, sonst schließt der Server den Socket nach 60 Sekunden Stille.
Märkte werden über `id` (`eventId:key`) identifiziert, ein Dictionary ist also der gesamte Zustand, den du brauchst. Jeder Ausgang hat `decimal`, `american`, `fair` (faire Quote ohne Marge) und `fairProb`. Die [WebSocket-Referenz](/docs/websocket) (auf Englisch) listet alle Felder.
## Schritt 3 — Der Python-Client
Installiere die einzige Abhängigkeit mit `pip install websockets` (Python 3.9+). Speichere die Datei als `pinnfeed_stream.py`; die Steam- und die Telegram-Anleitung importieren sie.
```python
# pinnfeed_stream.py: hält eine Live-Kopie des Pinnacle-Quotenbuchs aus dem PinnFeed-WebSocket.
# pip install websockets (Python 3.9+)
import asyncio, json, os, random
import websockets
WS_URL = os.environ.get("PINNFEED_WS", "wss://pinnfeed.io/v1/stream")
KEY = os.environ["PINNFEED_KEY"]
SIDES = {"home", "away", "draw", "over", "under"}
class Book:
"""Events und Märkte nach id, aktualisiert aus Snapshot- und Delta-Frames."""
def __init__(self):
self.events, self.markets = {}, {}
def apply(self, msg, on_market=None):
if msg["type"] == "snapshot":
for e in msg["events"]:
self.events[e["id"]] = e
for m in msg["markets"]:
self.markets[m["id"]] = m
elif msg["type"] == "delta":
for c in msg["changes"]:
if c["kind"] == "event" and c["op"] == "upsert":
self.events[c["event"]["id"]] = c["event"]
elif c["kind"] == "event" and c["op"] == "remove":
self.events.pop(c["id"], None)
for mid in [k for k, m in self.markets.items() if m["eventId"] == c["id"]]:
del self.markets[mid]
elif c["kind"] == "market" and c["op"] == "upsert":
old = self.markets.get(c["market"]["id"])
self.markets[c["market"]["id"]] = c["market"]
if on_market:
on_market(old, c["market"], self.events.get(c["market"]["eventId"]))
elif c["kind"] == "market" and c["op"] == "remove":
self.markets.pop(c["id"], None)
async def stream(subscription, on_market=None, on_ready=None):
"""Verbinden, abonnieren, Quotenbuch aktuell halten; mit Backoff endlos neu verbinden."""
delay = 1
while True:
book = Book()
try:
async with websockets.connect(WS_URL, additional_headers={"x-api-key": KEY}, max_size=None) as ws:
await ws.send(json.dumps({"type": "subscribe", **subscription}))
async for raw in ws:
msg = json.loads(raw)
if msg["type"] == "ping":
await ws.send('{"type":"pong"}')
elif msg["type"] == "error":
print("server error:", msg["code"], msg["message"])
elif msg["type"] in ("snapshot", "delta"):
book.apply(msg, on_market if msg["type"] == "delta" else None)
if msg["type"] == "snapshot" and msg.get("final") and on_ready:
on_ready(book)
delay = 1
except (OSError, websockets.ConnectionClosed) as e:
print(f"disconnected ({e}); reconnecting in {delay}s")
await asyncio.sleep(delay + random.random())
delay = min(delay * 2, 30)
if __name__ == "__main__":
def ready(book):
print(f"book ready: {len(book.events)} events, {len(book.markets)} markets")
def moved(old, new, event):
if old and event:
for o_old, o_new in zip(old["outcomes"], new["outcomes"]):
if o_new["name"] in SIDES and o_old["decimal"] != o_new["decimal"]:
print(f'{event["home"]} v {event["away"]} {new["type"]} {o_new["name"]}: '
f'{o_old["decimal"]} -> {o_new["decimal"]} (fair {o_new["fair"]})')
asyncio.run(stream({"sports": ["soccer"], "markets": ["moneyline"], "main": True, "specials": False}, moved, ready))
```
Starte ihn mit `python pinnfeed_stream.py`. Du siehst `book ready: N events, M markets` und danach eine Zeile pro Preisbewegung.
## Schritt 4 — Der Node-Client
Dieselbe Logik in Node 18+ mit `npm install ws`. Als `stream.mjs` speichern und `node stream.mjs` ausführen.
```javascript
// stream.mjs: Pinnacle-Quotenbuch live aus dem PinnFeed-WebSocket (Node 18+).
// npm install ws
import WebSocket from 'ws';
const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const KEY = process.env.PINNFEED_KEY;
const SIDES = new Set(['home', 'away', 'draw', 'over', 'under']);
const events = new Map();
const markets = new Map();
function connect(delay = 1000) {
const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': KEY }, perMessageDeflate: true });
ws.on('open', () => {
delay = 1000;
ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer', 'tennis'], markets: ['moneyline'], main: true, specials: false }));
});
ws.on('message', (raw) => {
const msg = JSON.parse(raw);
if (msg.type === 'ping') return ws.send('{"type":"pong"}');
if (msg.type === 'error') return console.error('server error:', msg.code, msg.message);
if (msg.type === 'snapshot') {
if (msg.part === 1) { events.clear(); markets.clear(); }
msg.events.forEach((e) => events.set(e.id, e));
msg.markets.forEach((m) => markets.set(m.id, m));
if (msg.final) console.log(`book ready: ${events.size} events, ${markets.size} markets`);
}
if (msg.type === 'delta') {
for (const c of msg.changes) {
if (c.kind === 'event') c.op === 'upsert' ? events.set(c.event.id, c.event) : events.delete(c.id);
if (c.kind === 'market' && c.op === 'remove') markets.delete(c.id);
if (c.kind === 'market' && c.op === 'upsert') {
const old = markets.get(c.market.id);
markets.set(c.market.id, c.market);
const ev = events.get(c.market.eventId);
if (!old || !ev) continue;
c.market.outcomes.forEach((o, i) => {
const prev = old.outcomes[i];
if (prev && SIDES.has(o.name) && prev.decimal !== o.decimal) console.log(`${ev.home} v ${ev.away} ${o.name}: ${prev.decimal} -> ${o.decimal} (fair ${o.fair})`);
});
}
}
}
});
ws.on('close', (code) => {
const wait = Math.min(delay * 2, 30000);
console.log(`closed (${code}); reconnecting in ${wait / 1000}s`);
setTimeout(() => connect(wait), wait + Math.random() * 1000);
});
ws.on('error', (e) => console.error('ws error:', e.message));
}
connect();
```
## Schritt 5 — Das Abo eingrenzen
Die Filter greifen serverseitig, du empfängst und verarbeitest also nur, was du anforderst:
```json
{ "type": "subscribe", "sports": ["tennis"], "live": true, "markets": ["moneyline", "total"], "main": true }
```
- `sports`: Slugs oder ids; `leagues` und `events`: Listen von ids.
- `live`: `true` nur Live, `false` nur Pre-Match; weglassen für beides.
- `main: true` behält pro Event nur Hauptsiegwette, Haupthandicap und Haupttotal.
- Ein erneutes `subscribe` ersetzt das Abo und schickt einen neuen Snapshot.
## Checkliste für den Produktivbetrieb
- **Mit Backoff und Jitter neu verbinden** (beide Clients tun das: 1 s, 2 s, 4 s, bis 30 s) und aus dem neuen Snapshot neu aufbauen.
- **Kompression aktivieren**: Pythons `websockets` handelt `permessage-deflate` standardmäßig aus; in Node `perMessageDeflate: true` übergeben. Snapshots schrumpfen um den Faktor 5 bis 10.
- **Schnell lesen.** Staut sich für einen langsamen Client mehr als 16 MB an, schließt der Server ihn mit Code `4008`. Schwere Arbeit gehört außerhalb der Socket-Schleife.
- **`seq` fürs Logging nutzen, nicht zur Lückenerkennung**: Filter überspringen Batches, die du nicht abonniert hast.
## Häufige Fragen
### Welchen Plan brauche ich für den WebSocket?
Builder (99 €/Monat) oder höher. Free- und Hobby-Keys erhalten auf dem WebSocket `403 plan_lacks_ws` und können REST nutzen.
### Wie viele Verbindungen kann ich öffnen?
Builder erlaubt 3 WebSocket-Verbindungen pro Konto, Pro 10, Enterprise 50 (mehr auf Anfrage).
### Warum haben manche Ausgänge Teilnehmer-ids statt home oder away?
Specials und manche Langzeitwetten listen Teilnehmer statt Heim- und Auswärtsteam. Abonniere mit `"specials": false` und filtere auf `home`, `away`, `draw`, `over` und `under`, wenn du nur Spiellinien willst, so wie die Beispiele.
---
Source: https://pinnfeed.io/de/guides/dropping-odds-steam-detection
# Dropping Odds und Steam Moves bei Pinnacle in Echtzeit erkennen
Ein **Steam Move** ist ein schneller, deutlicher Quotensturz bei einem marktführenden Buchmacher wie Pinnacle, meist weil Sharp-Geld auf eine Seite geflossen ist. Soft-Buchmacher hinken oft Sekunden oder Minuten hinterher, deshalb gehören Steam-Alerts zu den nützlichsten Signalen aus einem Live-Feed. In dieser Anleitung baust du einen Detektor auf dem PinnFeed-WebSocket. Er ist ein statistisches Werkzeug, kein Tippsystem.
## Schritt 1 — Festlegen, was Steam ist
Eine praxistaugliche Definition, die du anpassen kannst:
- die Dezimalquote eines Ausgangs **fällt um mindestens 5 %** gegenüber ihrem Höchstwert der letzten **2 Minuten**;
- der **Maximaleinsatz** des Markts liegt bei mindestens 100, denn Pinnacle erhöht die Limits, je sicherer es sich bei einem Preis ist; Bewegungen in dünnen Märkten sind verrauschter;
- du alarmierst **einmal pro Ausgang und Fenster**, nicht bei jedem Tick.
## Schritt 2 — Das Quotenbuch streamen
Nutze den Python-Client aus der [Python- und Node-Anleitung](/de/guides/pinnacle-odds-websocket-python-node). Speichere ihn als `pinnfeed_stream.py` neben dem Skript unten; er ruft `on_market(old, new, event)` auf, sobald sich ein Markt ändert.
## Schritt 3 — Das gleitende Maximum jedes Ausgangs verfolgen
Halte pro Markt und Ausgang eine kurze Deque mit `(timestamp, price)`, wirf alles weg, was älter als das Fenster ist, und vergleiche den aktuellen Preis mit dem Maximum im Fenster:
```python
# steam.py: meldet Steam Moves bei Pinnacle (schnelle, starke Quotenstürze) aus dem Live-WebSocket.
# Nutzt pinnfeed_stream.py aus der Python/Node-Anleitung. pip install websockets
import asyncio, collections, os, time
from pinnfeed_stream import stream, SIDES
WINDOW_S = int(os.environ.get("WINDOW_S", 120)) # Rückblickfenster
MIN_DROP = float(os.environ.get("MIN_DROP", 0.05)) # Alarm, wenn die Quote im Fenster um 5 % oder mehr fällt
MIN_STAKE = float(os.environ.get("MIN_STAKE", 100)) # dünne Märkte ignorieren: Pinnacles Maximaleinsatz ist ein Vertrauenssignal
history = collections.defaultdict(collections.deque) # (Markt-id, Ausgang) -> deque[(ts, decimal)]
alerted = {}
def on_market(old, new, event):
if not event or (new.get("maxStake") or 0) < MIN_STAKE:
return
now = time.time()
for o in new["outcomes"]:
if o["name"] not in SIDES:
continue
h = history[(new["id"], o["name"])]
h.append((now, o["decimal"]))
while h and now - h[0][0] > WINDOW_S:
h.popleft()
high = max(p for _, p in h)
drop = 1 - o["decimal"] / high
key = (new["id"], o["name"])
if drop >= MIN_DROP and now - alerted.get(key, 0) > WINDOW_S:
alerted[key] = now
pts = o.get("points")
line = "" if pts is None else f" {pts:g}" if new["type"] == "total" else f" {pts:+g}"
print(f'STEAM {event["sport"]} | {event["home"]} v {event["away"]} | {new["type"]}{line} {o["name"]}: '
f'{high:.3f} -> {o["decimal"]:.3f} (-{drop:.1%} in {WINDOW_S}s) fair {o["fair"]:.3f} max stake {new["maxStake"]}')
asyncio.run(stream({"sports": ["soccer", "tennis", "basketball"], "markets": ["moneyline", "spread", "total"],
"main": True, "specials": False}, on_market))
```
Starte es mit `python steam.py`. Die Schwellen sind Umgebungsvariablen, zum Beispiel `MIN_DROP=0.03 WINDOW_S=300 python steam.py` für 3 % in fünf Minuten. Eine typische Zeile:
```text
STEAM tennis | Sebastian Baez v Daniil Glinka | moneyline away: 2.260 -> 2.050 (-9.3% in 120s) fair 2.143 max stake 975
```
## Schritt 4 — Oder den REST-Endpoint fragen
Wenn dir eine regelmäßige Liste reicht, liefert `GET /v1/drops` die stärksten Quotenstürze in einem gleitenden Fenster, serverseitig berechnet:
```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/drops?sport=soccer&live=true&minutes=10&min_pct=5"
```
Jede Zeile enthält Event, Markt, Linie, Ausgang, `from`, `to`, `dropPct` und `movedAt`. Das funktioniert in allen Plänen, auch in Free mit seinen 30 Sekunden Verzögerung.
## Schritt 5 — Von Alerts zu Picks
- **Mit Soft-Buchmachern vergleichen.** Ein Steam Move nützt nur dort, wo sich der Soft-Preis noch nicht bewegt hat. Die [Value-Betting-Anleitung](/de/guides/value-betting-no-vig-fair-odds) zeigt, wie du diesen Vorteil mit Pinnacles fairen Quoten beziffern kannst.
- **Für den Rückstand der Soft-Buchmacher Pre-Match bevorzugen**; live gehen Bewegungen oft auf den Spielstand zurück und weniger auf Sharp-Geld.
- **Dich messen** mit dem [Closing Line Value](/de/guides/closing-line-value-clv-tracking): Schlagen deine Steam-Picks im Schnitt die Schlussquote, ist das Signal echt.
- **Veröffentlichen**: Der [Telegram-Tipp-Bot](/de/guides/telegram-picks-bot) und der [Discord-Picks-Bot](/de/guides/discord-picks-bot) schicken diese Alerts in einen Kanal.
## Häufige Fragen
### Was ist der Unterschied zwischen Dropping Odds und Steam?
Dropping Odds sind jede fallende Quote. Steam ist ein schneller, deutlicher Sturz bei einem Sharp-Buchmacher, meist ausgelöst durch informiertes Geld, der sich danach oft auf andere Buchmacher überträgt.
### Warum Pinnacle für die Steam-Erkennung?
Pinnacle akzeptiert hohe Limits und bewegt seine Preise mit der Sharp-Action, seine Bewegungen sind also das beste Marktsignal. Soft-Buchmacher kopieren sie oder ziehen später nach.
### Geht das auch ohne WebSocket?
Ja, per Polling von `/v1/drops`, das in allen Plänen funktioniert. Der WebSocket sieht jede Bewegung, wenn sie passiert; Polling sieht sie erst bei deiner nächsten Anfrage.
---
Source: https://pinnfeed.io/de/guides/value-betting-no-vig-fair-odds
# Value Bets bei Soft-Buchmachern mit Pinnacles fairen Quoten
Pinnacles Preise sind das, was im Wettmarkt einer echten Wahrscheinlichkeit am nächsten kommt. Entfernst du die Marge, erhältst du eine **faire Quote**; jeder Soft-Buchmacher, der mehr als diese Quote zahlt, bietet eine Wette mit positivem Erwartungswert (+EV). PinnFeed berechnet die faire Quote für jeden Markt, die Rechnung schrumpft also auf eine Multiplikation. +EV ist ein langfristiges statistisches Konzept, keine Gewinngarantie.
## Schritt 1 — Die faire Quote verstehen
Für einen Markt mit Dezimalquoten `d_i`:
```text
implied_i = 1 / d_i
margin = Σ implied_i − 1
fairProb_i = implied_i / Σ implied_j (multiplikative Methode)
fair_i = 1 / fairProb_i
```
Jeder Ausgang in der API hat bereits `fair` und `fairProb`, jeder Markt hat `margin`. Die Rohpreise sind ebenfalls dabei, falls du lieber die Power- oder die Shin-Methode anwendest.
## Schritt 2 — Den Erwartungswert berechnen
Bietet ein Soft-Buchmacher die Dezimalquote `S` auf einen Ausgang mit fairer Wahrscheinlichkeit `p`:
```text
EV = S × p − 1
```
Mit `S = 2.30` und `p = 0.488` (faire Quote 2.049) liegt der EV bei +12,3 %: Langfristig erwartest du 12,3 Cent pro eingesetztem Euro. Die meisten setzen eine Schwelle von 1–3 %, um Rauschen und die Zeit bis zur Platzierung abzufedern.
## Schritt 3 — Den Einsatz bestimmen
Voller Kelly (`(S·p − 1) / (S − 1)`) ist bei geschätzten Wahrscheinlichkeiten zu aggressiv. Ein Viertel-Kelly ist ein üblicher Kompromiss, und genau das gibt das Skript aus.
## Schritt 4 — Das Skript ausführen
Fülle `SOFT` mit den Quoten, die du bei einem Soft-Buchmacher gesammelt hast (von Hand, aus einem Quotenvergleich oder aus einer anderen API), mit den Teamnamen so, wie PinnFeed sie schreibt. Installiere `requests` und führe `python value.py` aus:
```python
# value.py: findet +EV-Quoten bei einem Soft-Buchmacher anhand von Pinnacles fairen Quoten ohne Marge.
# pip install requests
import os, requests
BASE = os.environ.get("PINNFEED_BASE", "https://pinnfeed.io")
KEY = os.environ["PINNFEED_KEY"]
# Quoten, die du bei einem Soft-Buchmacher gesammelt hast: (Heimteam, Auswärtsteam, Ausgang) -> Dezimalquote.
SOFT = {
("Osasuna", "Malaga", "home"): 1.95,
("Colon", "Defensor Sporting", "away"): 2.30,
}
MIN_EV = 0.02 # 2 % Vorteil
def kelly(price, p, fraction=0.25):
"""Fraktionaler Kelly-Einsatz als Anteil der Bankroll."""
return max(0.0, fraction * (price * p - 1) / (price - 1))
r = requests.get(f"{BASE}/v1/odds", headers={"x-api-key": KEY},
params={"sport": "soccer", "market": "moneyline", "main": "true", "limit": 1000}, timeout=20)
r.raise_for_status()
for ev in r.json()["events"]:
for m in ev["markets"]:
for o in m["outcomes"]:
soft = SOFT.get((ev["home"], ev["away"], o["name"]))
if not soft:
continue
ev_pct = soft * o["fairProb"] - 1 # Erwartungswert pro eingesetzter Einheit
flag = "VALUE" if ev_pct >= MIN_EV else "no edge"
print(f'{flag:8} {ev["home"]} v {ev["away"]} {o["name"]}: soft {soft} vs Pinnacle {o["decimal"]} '
f'(fair {o["fair"]:.3f}, margin {m["margin"]:.1%}) EV {ev_pct:+.1%} '
f'kelly/4 {kelly(soft, o["fairProb"]):.2%}')
```
Die Ausgabe sieht so aus:
```text
VALUE Colon v Defensor Sporting away: soft 2.3 vs Pinnacle 1.8065 (fair 2.049, margin 13.4%) EV +12.3% kelly/4 2.36%
```
Der REST-Aufruf funktioniert in allen Plänen; in Free sind die Preise 30 Sekunden alt. Für Live-Value brauchst du sie live: Mach denselben Vergleich im WebSocket-Client aus der [Python- und Node-Anleitung](/de/guides/pinnacle-odds-websocket-python-node), mit Builder.
## Schritt 5 — Mit dem CLV gegenprüfen
Kurzfristig sind Ergebnisse vor allem Varianz. Die schnellste ehrliche Antwort ist der **Closing Line Value**: Hat dein Preis Pinnacles faire Schlussquote geschlagen? Die [CLV-Anleitung](/de/guides/closing-line-value-clv-tracking) protokolliert jede Wette und misst sie.
## Häufige Fragen
### Warum Pinnacle als Referenz?
Pinnacle arbeitet mit niedrigen Margen und hohen Limits und bewegt seine Preise mit dem Sharp-Geld. Sein Preis ohne Marge gilt deshalb weithin als beste öffentliche Schätzung der wahren Wahrscheinlichkeit.
### Welche Methode nutzt PinnFeed zur Margenentfernung?
Die multiplikative (proportionale) Methode. Jeder Ausgang enthält die rohen Dezimal- und amerikanischen Quoten, du kannst also eine andere Methode verwenden.
### Liefert PinnFeed Quoten von Soft-Buchmachern?
Nein. PinnFeed liefert nur Pinnacle. Kombiniere es mit deinen eigenen Soft-Quoten oder einer API für mehrere Buchmacher wie The Odds API.
---
Source: https://pinnfeed.io/de/guides/closing-line-value-clv-tracking
# Deinen Closing Line Value gegen Pinnacles Schlussquote messen
Der **Closing Line Value (CLV)** vergleicht den Preis, den du bekommen hast, mit dem letzten Marktpreis vor dem Anpfiff. Pinnacles faire Schlussquote regelmäßig zu schlagen ist das stärkste frühe Signal, dass dein Prozess einen Vorteil hat, lange bevor deine Gewinn- und Verlustrechnung das zeigen kann, aber nie eine Gewinngarantie. PinnFeed speichert Pinnacles Schlussquote für jeden Markt beim Eventstart und liefert sie über `/v1/closing`.
## Schritt 1 — Die Formel
```text
CLV = price_taken / closing_fair_price − 1
```
Nimm die Schlussquote **ohne Marge**, nicht die Rohquote: Einen Preis zu schlagen, der noch Pinnacles Marge enthält, ist leichter und übertreibt deinen Vorteil. Hast du 2.10 genommen und der Markt schloss bei einer fairen Quote von 1.95, liegt dein CLV bei +7,7 %.
## Schritt 2 — Jede Wette protokollieren
Jede Wette braucht Event-id, Marktschlüssel und Ausgang. Alle drei kommen aus der API: die `id` des Events, der `key` des Markts (`s;0;m` ist die Siegwette für das ganze Spiel, `s;0;ou;2.5` Über/Unter 2,5 für das ganze Spiel) und der `name` des Ausgangs (`home`, `away`, `draw`, `over`, `under`).
## Schritt 3 — Den Tracker ausführen
Installiere `requests`, speichere das Skript als `clv.py` und protokolliere Wetten, sobald du sie platzierst:
```python
# clv.py: protokolliert deine Wetten und misst den Closing Line Value (CLV) gegen Pinnacles Schlussquote ohne Marge.
# pip install requests Aufruf:
# python clv.py bet z. B. bet 1640141281 "s;0;m" home 2.10
# python clv.py report
import os, sqlite3, sys, requests
BASE = os.environ.get("PINNFEED_BASE", "https://pinnfeed.io")
KEY = os.environ["PINNFEED_KEY"]
db = sqlite3.connect(os.environ.get("CLV_DB", "bets.db"))
db.execute("CREATE TABLE IF NOT EXISTS bets (event_id INTEGER, market_key TEXT, outcome TEXT, price REAL, "
"close_fair REAL, placed_at TEXT DEFAULT CURRENT_TIMESTAMP)")
def closing_fair(event_id, market_key, outcome):
r = requests.get(f"{BASE}/v1/closing/{event_id}", headers={"x-api-key": KEY}, timeout=20)
if r.status_code == 404:
return None # noch keine Schlussquote (oder nie erfasst)
r.raise_for_status()
for rec in r.json()["markets"]:
if rec["market"]["key"] == market_key:
for o in rec["market"]["outcomes"]:
if o["name"] == outcome:
return o["fair"]
return None
if sys.argv[1:2] == ["bet"]:
_, _, event_id, market_key, outcome, price = sys.argv
db.execute("INSERT INTO bets (event_id, market_key, outcome, price) VALUES (?,?,?,?)",
(int(event_id), market_key, outcome, float(price)))
db.commit()
print("logged")
else:
rows = db.execute("SELECT rowid, event_id, market_key, outcome, price, close_fair FROM bets").fetchall()
clvs = []
for rowid, event_id, key, outcome, price, close in rows:
if close is None:
close = closing_fair(event_id, key, outcome)
if close:
db.execute("UPDATE bets SET close_fair=? WHERE rowid=?", (close, rowid))
if close:
clv = price / close - 1
clvs.append(clv)
print(f"{event_id} {key} {outcome}: took {price}, closed fair {close:.3f} -> CLV {clv:+.2%}")
else:
print(f"{event_id} {key} {outcome}: took {price}, waiting for close")
db.commit()
if clvs:
print(f"average CLV over {len(clvs)} bets: {sum(clvs) / len(clvs):+.2%}")
```
```bash
python clv.py bet 1640229582 "s;0;m" home 2.10
python clv.py report
```
```text
1640229582 s;0;m home: took 2.1, closed fair 3.181 -> CLV -33.99%
999 s;0;m home: took 1.9, waiting for close
average CLV over 1 bets: -33.99%
```
Lass `report` nach den Anstoßzeiten per Cron laufen; die Schlussquote jeder Wette wird einmal abgefragt und gespeichert.
## Schritt 4 — Das Ergebnis lesen
- Über einige hundert Wetten ist ein durchschnittlicher CLV von **+2 % oder mehr** ein starkes Indiz für einen echten Vorteil.
- Negativer CLV bei positivem Gewinn ist meist Glück. Das verwässert sich in der Regel.
- Schlüssle den CLV nach Sportart, Markt und Vorlaufzeit auf: So siehst du, woher dein Vorteil wirklich kommt.
## Schritt 5 — Einen ganzen Tag herunterladen
Für Forschung oder Backtests ruf alle Schlusslinien eines UTC-Tages ab:
```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/closing?date=2026-11-08&sport=soccer&main=true"
```
## Häufige Fragen
### Welcher Plan enthält die Schlussquoten?
Die Historie der Schlussquoten ist ab Builder (99 €/Monat) sowie in Pro und Enterprise enthalten.
### Wann wird die Schlussquote erfasst?
Beim Eventstart: Für jeden Markt wird der letzte Pre-Match-Preis mit Erfassungszeit gespeichert.
### Wie weit reicht das Archiv zurück?
Es beginnt mit dem Starttag des Dienstes und wächst täglich. Enterprise-Pläne können es als CSV oder Parquet in großen Mengen exportieren.
---
Source: https://pinnfeed.io/de/guides/telegram-picks-bot
# Einen Telegram-Tipp-Bot mit Pinnacle-Live-Quoten bauen
Dieser Bot beobachtet Pinnacles Preise im PinnFeed-WebSocket und postet eine Nachricht in einen Telegram-Kanal, sobald ein Markt Steam zeigt, also wenn seine Quote in zwei Minuten um 5 % oder mehr fällt, in einem Markt mit vernünftigem Maximaleinsatz. Es ist eine einzige Datei mit rund 70 Zeilen, ohne Telegram-Bibliothek: Sie ruft die Bot API direkt auf.
## Schritt 1 — Den Bot anlegen
1. Öffne in Telegram **@BotFather**, sende `/newbot` und folge den Anweisungen. Kopiere das Token.
2. Leg einen Kanal an und füge den Bot als **Administrator** mit Berechtigung zum Posten hinzu.
3. Nutze den öffentlichen Kanalnamen (`@mychannel`) als Chat-id oder die numerische id für einen privaten Chat.
## Schritt 2 — Die Umgebung einrichten
```bash
export PINNFEED_KEY="ps_live_..." # Builder-Plan (WebSocket)
export TELEGRAM_TOKEN="123456:ABC..." # von @BotFather
export TELEGRAM_CHAT="@mychannel"
npm install ws
```
Lässt du `TELEGRAM_TOKEN` weg, läuft der Bot im **Testmodus**: Er gibt die Nachrichten aus, statt sie zu senden.
## Schritt 3 — Der Bot
Als `telegram-picks-bot.mjs` speichern:
```javascript
// telegram-picks-bot.mjs: postet Pinnacle-Steam-Moves als "Picks" in einen Telegram-Kanal.
// npm install ws Node 18+ (global fetch)
// Umgebung: PINNFEED_KEY, TELEGRAM_TOKEN (von @BotFather), TELEGRAM_CHAT (z. B. @mychannel oder eine Chat-id)
import WebSocket from 'ws';
const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const { PINNFEED_KEY, TELEGRAM_TOKEN, TELEGRAM_CHAT } = process.env;
const MIN_DROP = Number(process.env.MIN_DROP || 0.05); // 5 % Quotensturz...
const WINDOW_MS = Number(process.env.WINDOW_MS || 120000); // ...innerhalb von 2 Minuten
const SIDES = new Set(['home', 'away', 'draw', 'over', 'under']);
const events = new Map();
const highs = new Map(); // "marketId|outcome" -> [{t, p}]
const sent = new Map(); // "marketId|outcome" -> Zeit des letzten Alarms
async function post(text) {
if (!TELEGRAM_TOKEN) return console.log('[dry run]', text);
const r = await fetch(`https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage`, {
method: 'POST', headers: { 'content-type': 'application/json' },
body: JSON.stringify({ chat_id: TELEGRAM_CHAT, text, disable_web_page_preview: true }),
});
if (!r.ok) console.error('telegram', r.status, await r.text());
}
function check(m) {
const ev = events.get(m.eventId);
if (!ev || (m.maxStake ?? 0) < 100) return;
const now = Date.now();
for (const o of m.outcomes) {
if (!SIDES.has(o.name)) continue;
const k = `${m.id}|${o.name}`;
const h = (highs.get(k) || []).filter((x) => now - x.t < WINDOW_MS);
h.push({ t: now, p: o.decimal });
highs.set(k, h);
const high = Math.max(...h.map((x) => x.p));
const drop = 1 - o.decimal / high;
if (drop < MIN_DROP || now - (sent.get(k) || 0) < WINDOW_MS) continue;
sent.set(k, now);
const pick = o.name === 'home' ? ev.home : o.name === 'away' ? ev.away : o.name;
const line = o.points == null ? '' : m.type === 'total' ? ` ${o.points}` : ` ${o.points > 0 ? '+' : ''}${o.points}`;
post(`📉 ${ev.sport.toUpperCase()} · ${ev.league?.name ?? ''}\n${ev.home} v ${ev.away}\n` +
`Pick: ${pick} (${m.type}${line})\nPinnacle ${high.toFixed(2)} → ${o.decimal.toFixed(2)} (−${(drop * 100).toFixed(1)}%)\n` +
`Fair now ${o.fair.toFixed(2)} · max stake ${m.maxStake}`);
}
}
function connect(delay = 1000) {
const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': PINNFEED_KEY }, perMessageDeflate: true });
ws.on('open', () => {
delay = 1000;
ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer', 'tennis', 'basketball'], markets: ['moneyline', 'spread', 'total'], main: true, specials: false }));
});
ws.on('message', (raw) => {
const msg = JSON.parse(raw);
if (msg.type === 'ping') return ws.send('{"type":"pong"}');
if (msg.type === 'snapshot') msg.events.forEach((e) => events.set(e.id, e));
if (msg.type === 'delta') for (const c of msg.changes) {
if (c.kind === 'event') c.op === 'upsert' ? events.set(c.event.id, c.event) : events.delete(c.id);
if (c.kind === 'market' && c.op === 'upsert') check(c.market);
}
});
ws.on('close', () => setTimeout(() => connect(Math.min(delay * 2, 30000)), delay));
ws.on('error', (e) => console.error('ws error:', e.message));
}
connect();
```
## Schritt 4 — Starten und testen
```bash
node telegram-picks-bot.mjs
```
Eine Nachricht sieht so aus:
```text
📉 SOCCER · Italy - Serie A
Udinese v Fiorentina
Pick: Udinese (spread +0.25)
Pinnacle 1.88 → 1.70 (−9.5%)
Fair now 1.83 · max stake 150
```
Die Menge steuerst du mit `MIN_DROP` und `WINDOW_MS`, zum Beispiel `MIN_DROP=0.08` für weniger, dafür stärkere Alerts.
## Schritt 5 — Dauerhaft betreiben
- Betreibe ihn mit `systemd`, `pm2` oder einem Container, der bei Absturz neu startet; der Bot verbindet sich selbst wieder mit dem WebSocket.
- Telegram erlaubt rund 20 Nachrichten pro Minute und Gruppe oder Kanal. Erhöhe `MIN_DROP`, wenn du `429`-Antworten bekommst.
- Veröffentliche deine Bilanz ehrlich: Protokolliere jeden Pick und miss ihn am [Closing Line Value](/de/guides/closing-line-value-clv-tracking).
## Häufige Fragen
### Welchen PinnFeed-Plan braucht der Bot?
Builder (99 €/Monat) oder höher, weil er den WebSocket nutzt. Für einen langsameren Bot mit Free oder Hobby pollst du `/v1/drops` jede Minute.
### Kann ich die Picks auch in Discord posten?
Ja. Ersetze die Funktion `post` durch einen POST an die URL eines Discord-Webhooks mit dem Body `{"content": text}`. Die vollständige Anleitung (Embeds, Sendewarteschlange und 429-Behandlung) steht im [Discord-Picks-Bot](/de/guides/discord-picks-bot).
### Ist es erlaubt, Tipps zu veröffentlichen?
Die Regeln für Wett-Tipps und Glücksspielwerbung unterscheiden sich von Land zu Land; in Deutschland regelt etwa der Glücksspielstaatsvertrag 2021 auch die Werbung für Sportwetten. Prüfe die Regeln dort, wo du und dein Publikum seid, richte dich nur an Erwachsene ab 18 Jahren und stelle Picks nie als sicher dar. Das ist keine Rechtsberatung.
---
Source: https://pinnfeed.io/de/guides/pinnacle-odds-chatgpt-claude-mcp
# Pinnacle-Live-Quoten in ChatGPT und Claude mit MCP
PinnFeed betreibt einen gehosteten [Model-Context-Protocol](https://modelcontextprotocol.io)-Server. Du fügst ihn einmal zu deinem Assistenten hinzu, und der kann Pinnacle-Quoten für Live und Pre-Match, Dropping Odds, faire Quoten und Schlussquoten abfragen, wenn du ihn darum bittest. Kein Einfügen von Daten, kein Code.
## Schritt 1 — Ein Key für den Assistenten
Leg im [Dashboard](/dashboard) einen eigenen Key mit dem Namen des Assistenten an (zum Beispiel "claude"), damit du ihn einzeln widerrufen kannst. Jeder Tool-Aufruf zählt als eine REST-Anfrage deines Plans; Free funktioniert mit 30 Sekunden verzögerten Daten.
## Schritt 2 — Den Server hinzufügen
**Claude Code**
```bash
claude mcp add --transport http pinnfeed https://pinnfeed.io/mcp --header "Authorization: Bearer YOUR_KEY"
```
**Claude (Web und Desktop):** Settings → Connectors → Add custom connector, URL `https://pinnfeed.io/mcp?key=YOUR_KEY`.
**ChatGPT:** Settings → Apps & Connectors → Advanced → Developer mode aktivieren und einen Connector mit der Server-URL `https://pinnfeed.io/mcp?key=YOUR_KEY` und ohne Authentifizierung anlegen.
**Cursor** (`~/.cursor/mcp.json`):
```json
{ "mcpServers": { "pinnfeed": { "url": "https://pinnfeed.io/mcp", "headers": { "Authorization": "Bearer YOUR_KEY" } } } }
```
Die Snippets für VS Code Copilot und Codex CLI stehen in der [MCP-Dokumentation](/docs/mcp) (auf Englisch).
## Schritt 3 — Fragen
Der Assistent wählt das Tool. Prompts, die gut funktionieren (du kannst sie auf Deutsch schreiben):
- „Welche Fußballquoten sind bei Pinnacle in den letzten 15 Minuten am stärksten gefallen?“ (`get_drops`)
- „Zeig mir die Live-Siegwetten im Tennis mit fairer Quote ohne Marge und Marge.“ (`get_live_odds`)
- „Wie lautet die faire Quote für Bayern gegen Dortmund und wie hoch ist der Maximaleinsatz?“ (`search_events`, dann `get_event`)
- „Ein Soft-Buchmacher bietet 2.30 auf Auswärtssieg bei Colon gegen Defensor Sporting. Ist das +EV gegenüber Pinnacle?“ (`get_event`, der Assistent rechnet)
- „Gib mir die Schlussquoten für Event 1640229582.“ (`get_closing_odds`, ab Builder)
## Schritt 4 — Ohne Assistent testen
Der Server spricht JSON-RPC über HTTP, du kannst also jedes Tool mit curl testen:
```bash
curl -s https://pinnfeed.io/mcp -H "Authorization: Bearer $PINNFEED_KEY" \
-H "content-type: application/json" -H "accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_drops","arguments":{"sport":"soccer","minutes":15}}}'
```
Das Ergebnis ist ein JSON-Textblock mit den Quotenstürzen: Event, Markt, Linie, Ausgang, `from`, `to`, `dropPct` und `movedAt`.
## Schritt 5 — In Code überführen
Wenn aus einer Frage eine Strategie wird, gehört sie in Code: Die [Steam-Anleitung](/de/guides/dropping-odds-steam-detection) und die [Value-Betting-Anleitung](/de/guides/value-betting-no-vig-fair-odds) machen dasselbe dauerhaft auf dem WebSocket.
## Häufige Fragen
### Welche Tools stellt der MCP-Server von PinnFeed bereit?
`get_account`, `list_sports`, `search_events`, `get_live_odds`, `get_prematch_odds`, `get_event`, `get_drops` und `get_closing_odds`.
### Braucht der MCP-Server einen bezahlten Plan?
Nein. Er funktioniert in allen Plänen mit deren Limits: Free hat 30 Sekunden Verzögerung und 1.000 Anfragen pro Tag. Schlussquoten erfordern Builder oder höher.
### Ist es sicher, meinen Key in eine URL zu schreiben?
Behandle ihn wie ein Passwort. Nutze einen eigenen Key pro Assistent und widerrufe ihn im Dashboard, falls er öffentlich wird.
---
Source: https://pinnfeed.io/de/guides/pinnacle-odds-google-sheets
# Pinnacle-Quoten in Google Sheets
Diese Anleitung schreibt Pinnacles 1X2-Quoten im Fußball in ein Google-Sheets-Blatt: eine Zeile pro Spiel, mit Dezimalquoten, fairen Quoten ohne Marge und der Marge des Markts. Ein zeitgesteuerter Trigger aktualisiert das Blatt alle 15 Minuten. Das Skript nutzt die REST-API von PinnFeed und funktioniert daher im **Free**-Plan (0 €, 30 Sekunden Verzögerung, 1.000 Anfragen/Tag).
## Schritt 1 — Einen Free-Key holen
1. Leg ein Konto auf [pinnfeed.io](/signup) an und öffne das [Dashboard](/dashboard).
2. Erstelle einen Key und kopiere ihn. Keys haben die Form `ps_live_…`.
3. Wähle in Free bis zu zwei Sportarten im Dashboard. Das Skript nutzt standardmäßig Fußball (`soccer`); ändere `SPORT`, wenn du etwas anderes gewählt hast.
Für Sheets brauchst du kein Builder. Builder (99 €/Monat, der WebSocket-Plan) ist für Echtzeit-Push-Clients wie in der [Python- und Node-Anleitung](/de/guides/pinnacle-odds-websocket-python-node).
## Schritt 2 — Die Tabelle anlegen
1. Leg eine neue Google-Sheets-Tabelle an.
2. Benenne das erste Tabellenblatt in **Odds** um (genau so; das Skript sucht diesen Namen).
3. Öffne **Erweiterungen → Apps Script**. Lösch die Beispielfunktion `myFunction`, damit das Projekt für den nächsten Schritt leer ist.
## Schritt 3 — Skript einfügen und Eigenschaften setzen
Füge das in `Code.gs` ein:
```javascript
// Google Apps Script: Erweiterungen → Apps Script, diese Datei einfügen.
// Skripteigenschaften (Projekteinstellungen → Skripteigenschaften):
// PINNFEED_BASE = https://pinnfeed.io
// PINNFEED_KEY = ps_live_...
// Ein Tabellenblatt namens "Odds" anlegen, refreshOdds einmal ausführen, dann einen 15-Minuten-Trigger hinzufügen.
const PROPS = PropertiesService.getScriptProperties();
const BASE = PROPS.getProperty('PINNFEED_BASE') || 'https://pinnfeed.io';
const KEY = PROPS.getProperty('PINNFEED_KEY');
const SPORT = 'soccer'; // auf basketball, tennis, … ändern (muss in deinem Plan enthalten sein)
function refreshOdds() {
if (!KEY) {
console.error('Set script property PINNFEED_KEY first');
return;
}
const url = BASE + '/v1/odds'
+ '?sport=' + encodeURIComponent(SPORT)
+ '&market=moneyline&main=true&live=false&limit=500';
const res = UrlFetchApp.fetch(url, {
headers: { 'x-api-key': KEY },
muteHttpExceptions: true,
});
const code = res.getResponseCode();
if (code !== 200) {
console.warn('PinnFeed HTTP ' + code + ': ' + res.getContentText().slice(0, 300));
return; // schlägt der Abruf fehl, bleibt das Blatt unverändert
}
const data = JSON.parse(res.getContentText());
const rows = [];
for (const ev of data.events || []) {
const ml = (ev.markets || []).find((m) => m.type === 'moneyline' && m.main);
if (!ml) continue;
const byName = {};
for (const o of ml.outcomes || []) byName[o.name] = o;
const home = byName.home || {};
const draw = byName.draw || {};
const away = byName.away || {};
rows.push([
ev.startTime ? new Date(ev.startTime) : '',
(ev.league && ev.league.name) || '',
ev.home || '',
ev.away || '',
home.decimal || '',
draw.decimal || '',
away.decimal || '',
home.fair || '',
draw.fair || '',
away.fair || '',
ml.margin != null ? ml.margin : '',
ev.id,
]);
}
const sheet = SpreadsheetApp.getActive().getSheetByName('Odds');
if (!sheet) {
console.error('Create a tab named Odds first');
return;
}
sheet.clearContents();
sheet.appendRow([
'Starts', 'League', 'Home', 'Away',
'1', 'X', '2',
'Fair 1', 'Fair X', 'Fair 2',
'Margin', 'Event id',
]);
if (rows.length) {
sheet.getRange(2, 1, rows.length, 12).setValues(rows);
}
console.log('Wrote ' + rows.length + ' moneyline rows for ' + SPORT);
}
```
Öffne dann das Zahnrad des Projekts (**Projekteinstellungen**) und füge unter **Skripteigenschaften** hinzu:
| Eigenschaft | Wert |
|---|---|
| `PINNFEED_KEY` | dein Key (`ps_live_…`) |
| `PINNFEED_BASE` | `https://pinnfeed.io` (optional; das ist der Standardwert) |
Füge den Key nie in Zellen der Tabelle ein und teile das Apps-Script-Projekt nie öffentlich.
## Schritt 4 — Einmal ausführen und autorisieren
1. Wähle `refreshOdds` im Funktions-Dropdown und klicke auf **Ausführen**.
2. Google fragt nach der Berechtigung, sich mit einem externen Dienst zu verbinden und die Tabelle zu bearbeiten. Erlaube es für dein Konto.
3. Lade die Tabelle neu. Das Blatt Odds sollte die Spalten `Starts`, `League`, `Home`, `Away`, `1`, `X`, `2`, die drei fairen Quoten, `Margin` und `Event id` zeigen.
Schlägt ein Aufruf fehl (falscher Key, Anfragelimit, Sportart nicht in deinem Plan), protokolliert das Skript eine Warnung und **lässt die bisherigen Zeilen stehen**, eine schlechte Minute leert dein Dashboard also nie.
## Schritt 5 — Einen 15-Minuten-Trigger hinzufügen
1. Öffne in Apps Script **Trigger** (Uhrsymbol) → **Trigger hinzufügen**.
2. Funktion: `refreshOdds`. Ereignisquelle: **Zeitgesteuert**. Typ: **Minuten-Timer**. Intervall: **Alle 15 Minuten**.
3. Speichern.
Das sind 96 Aufrufe pro Tag für eine Sportart, deutlich unter den 1.000 Anfragen/Tag und 1 Req/s des Free-Plans. Zwei Sportarten alle 30 Minuten ergeben ebenfalls 96. Siehe [Pläne und Limits](/docs/limits) (auf Englisch).
| Trigger | Aufrufe / Tag | Passt in Free? |
|---|---|---|
| Alle 15 Min., 1 Sportart | 96 | ja |
| Alle 30 Min., 2 Sportarten | 96 | ja |
| Alle 15 Min., 2 Sportarten | 192 | ja |
| Jede Minute, 1 Sportart | 1.440 | nein — braucht Hobby oder höher (ohne Tageskontingent) |
Apps Script hat zusätzlich eigene Kontingente; der kürzeste zeitgesteuerte Trigger ist eine Minute.
## Schritt 6 — Faire Quoten und Margen lesen
Jede 1X2-Zeile enthält die margenfreien Felder von PinnFeed, beschrieben im [Schema](/docs/schema):
- `Fair 1` / `Fair X` / `Fair 2` — die faire Dezimalquote `fair` jedes Ausgangs (Marge entfernt, multiplikative Methode).
- `Margin` — die `margin` des Markts (Overround = Summe der impliziten Wahrscheinlichkeiten − 1).
Nutze diese Spalten, wenn du in einem anderen Blatt die Quote eines Soft-Buchmachers vergleichst: Der Erwartungswert ist `soft × (1 / fair) − 1`, dieselbe Rechnung wie in der [Value-Betting-Anleitung](/de/guides/value-betting-no-vig-fair-odds). Für Live-Steam-Moves ist Sheets nicht das richtige Werkzeug: Nimm den Builder-WebSocket und die [Anleitung zur Steam-Erkennung](/de/guides/dropping-odds-steam-detection).
## Häufige Fragen
### Welchen PinnFeed-Plan brauche ich?
Free reicht für ein verzögertes Dashboard, das sich alle paar Minuten aktualisiert. Hobby (29 €/Monat) entfernt das Tageskontingent und die 30 Sekunden Verzögerung, bleibt aber reines REST. Echtzeit-Push braucht [Builder](/de/pricing#plan-builder) (99 €/Monat).
### Warum nutzt das Skript `x-api-key` statt eines URL-Parameters?
Das ist der empfohlene Authentifizierungs-Header laut [Dokumentation](/docs/authentication). `UrlFetchApp` in Apps Script kann Header senden, es gibt also keinen Grund, den Key in die URL zu schreiben (wo er in Logs landen kann).
### Kann ich die Preisentwicklung als Diagramm darstellen?
Ja. Lass das Blatt Odds als Live-Dashboard (es wird bei jedem Lauf geleert und neu geschrieben). Leg ein zweites Blatt an, das nach jeder Aktualisierung nur Zeilen anhängt, und füge ein Liniendiagramm ein. Lösch das Verlaufsblatt nicht.
### Ist das Bildungsinhalt für Erwachsene?
Ja. Die Quotendaten und Tabellen-Tools sind Bildungsmaterial für Erwachsene ab 18 Jahren. Nichts davon ist ein Tipp, eine sichere Wette oder ein Gewinnversprechen.
## Verwandte Seiten
- [REST-API-Referenz](/docs/rest) (auf Englisch) — Filter und Paginierung von `/v1/odds`
- [Value Betting mit fairen Quoten ohne Marge](/de/guides/value-betting-no-vig-fair-odds)
- [Telegram-Tipp-Bot](/de/guides/telegram-picks-bot) — wenn die Tabelle nicht mehr reicht
- [Preise](/de/pricing)
---
Source: https://pinnfeed.io/de/guides/discord-picks-bot
# Einen Discord-Picks-Bot mit Live-Quoten von Pinnacle bauen
Dieser Bot beobachtet die Pinnacle-Preise im PinnFeed-WebSocket und postet ein Embed in einen Discord-Kanal, sobald ein Markt steamt: Die Quote fällt innerhalb von zwei Minuten um 5 % oder mehr, in einem Markt mit einem Maximaleinsatz von mindestens 100. Es ist eine einzige Datei mit rund 90 Zeilen. Sie braucht weder eine Discord-Bibliothek noch einen Bot-Account, weil sie über einen **eingehenden Webhook** des Kanals postet.
Er ist das Discord-Gegenstück zum [Telegram-Picks-Bot](/de/guides/telegram-picks-bot). Die Erkennungsregel erklärt die [Anleitung zur Steam-Erkennung](/de/guides/dropping-odds-steam-detection). Das ist ein Lernwerkzeug für Erwachsene ab 18 Jahren, keine Wett-Tipps.
## Schritt 1 — Den Webhook anlegen
1. Öffne in deinem Discord-Server **Servereinstellungen → Integrationen → Webhooks** und wähle **Neuer Webhook**.
2. Gib ihm einen Namen, wähle den Kanal, in den er posten soll, und nutze **Webhook-URL kopieren**.
3. Behandle diese URL wie ein Passwort: Wer sie hat, kann in den Kanal posten. Wenn sie öffentlich wird, lösche den Webhook und lege einen neuen an.
## Schritt 2 — Die Umgebung einrichten
```bash
export PINNFEED_KEY="ps_live_..." # Builder-Plan (WebSocket)
export DISCORD_WEBHOOK="https://discord.com/api/webhooks/..." # aus Schritt 1
npm install ws
```
Lässt du `DISCORD_WEBHOOK` leer, läuft der Bot im **Testmodus**: Er gibt jede Meldung aus, statt sie zu posten.
Der Stream braucht **Builder** (99 €/Monat) oder höher. Free- und Hobby-Schlüssel erhalten auf `/v1/stream` den Fehler `403 plan_lacks_ws`; siehe [Preise](/de/pricing).
## Schritt 3 — Der Bot
Speichere ihn als `discord-picks-bot.mjs`:
```javascript
// discord-picks-bot.mjs: post Pinnacle steam moves to a Discord channel through an incoming webhook.
// npm install ws Node 18+ (global fetch)
// env: PINNFEED_KEY (Builder or higher), DISCORD_WEBHOOK (channel webhook URL; unset = dry run)
import WebSocket from 'ws';
const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const { PINNFEED_KEY, DISCORD_WEBHOOK } = process.env;
const MIN_DROP = Number(process.env.MIN_DROP || 0.05); // 5% shortening...
const WINDOW_MS = Number(process.env.WINDOW_MS || 120000); // ...inside 2 minutes
const MIN_STAKE = Number(process.env.MIN_STAKE || 100); // skip thin markets
const SIDES = new Set(['home', 'away', 'draw', 'over', 'under']);
const events = new Map();
const highs = new Map(); // "marketId|outcome" -> [{t, p}]
const sent = new Map(); // "marketId|outcome" -> last alert time
const queue = []; // embeds waiting to be posted
let busy = false;
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
// One worker drains the queue, so a slow or rate-limited webhook never blocks the stream.
async function drain() {
if (busy) return;
busy = true;
while (queue.length) {
const embed = queue.shift();
if (!DISCORD_WEBHOOK) { console.log('[dry run]', embed.title, '|', embed.description.replace(/\n/g, ' | ')); continue; }
for (let attempt = 0; attempt < 3; attempt++) {
const r = await fetch(DISCORD_WEBHOOK, {
method: 'POST', headers: { 'content-type': 'application/json' },
body: JSON.stringify({ embeds: [embed], allowed_mentions: { parse: [] } }),
}).catch((e) => ({ ok: false, status: 0, text: async () => e.message }));
if (r.status === 429) { const b = await r.json().catch(() => ({})); await sleep(1000 * (b.retry_after ?? 1)); continue; }
if (!r.ok) console.error('discord', r.status, await r.text());
break;
}
}
busy = false;
}
function post(embed) {
queue.push(embed);
if (queue.length > 50) queue.shift(); // an alert from minutes ago is no longer news
drain();
}
function check(m) {
const ev = events.get(m.eventId);
if (!ev || (m.maxStake ?? 0) < MIN_STAKE) return;
const now = Date.now();
for (const o of m.outcomes) {
if (!SIDES.has(o.name)) continue;
const k = `${m.id}|${o.name}`;
const h = (highs.get(k) || []).filter((x) => now - x.t < WINDOW_MS);
h.push({ t: now, p: o.decimal });
highs.set(k, h);
const high = Math.max(...h.map((x) => x.p));
const drop = 1 - o.decimal / high;
if (drop < MIN_DROP || now - (sent.get(k) || 0) < WINDOW_MS) continue;
sent.set(k, now);
const pick = o.name === 'home' ? ev.home : o.name === 'away' ? ev.away : o.name;
const line = o.points == null ? '' : m.type === 'total' ? ` ${o.points}` : ` ${o.points > 0 ? '+' : ''}${o.points}`;
post({
title: `📉 ${ev.home} v ${ev.away}`,
description: `**${pick}** (${m.type}${line})\nPinnacle ${high.toFixed(2)} → ${o.decimal.toFixed(2)} (−${(drop * 100).toFixed(1)}%)\n` +
`Fair now ${o.fair.toFixed(2)} · max stake ${m.maxStake}`,
color: 0xe8590c,
footer: { text: `${ev.sport.toUpperCase()} · ${ev.league?.name ?? ''} · 18+ · not a tip` },
timestamp: new Date(now).toISOString(),
});
}
}
function connect(delay = 1000) {
const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': PINNFEED_KEY }, perMessageDeflate: true });
ws.on('open', () => {
delay = 1000;
ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer', 'tennis', 'basketball'], markets: ['moneyline', 'spread', 'total'], main: true, specials: false }));
});
ws.on('message', (raw) => {
const msg = JSON.parse(raw);
if (msg.type === 'ping') return ws.send('{"type":"pong"}');
if (msg.type === 'snapshot') msg.events.forEach((e) => events.set(e.id, e));
if (msg.type === 'delta') for (const c of msg.changes) {
if (c.kind === 'event') c.op === 'upsert' ? events.set(c.event.id, c.event) : events.delete(c.id);
if (c.kind === 'market' && c.op === 'upsert') check(c.market);
}
});
ws.on('close', () => setTimeout(() => connect(Math.min(delay * 2, 30000)), delay));
ws.on('error', (e) => console.error('ws error:', e.message));
}
connect();
```
Was er der Reihe nach tut:
- **Abonniert** die Hauptlinien (Moneyline, Spread, Total) für Fußball, Tennis und Basketball. Ersetze `sports` durch eine der 13 Sportarten deines Plans; das [WebSocket-Protokoll](/docs/websocket) (auf Englisch) listet alle Filter.
- **Führt ein 2-Minuten-Fenster** pro Markt und Ausgang und meldet einen Rückgang um `MIN_DROP` gegenüber dem Höchstwert im Fenster. Märkte unter `MIN_STAKE` werden übersprungen, weil eine Bewegung bei niedrigem Limit wenig aussagt.
- **Stellt Posts in eine Warteschlange.** Ein einzelner Worker schickt die Embeds an den Webhook, sodass ein langsamer oder gedrosselter Webhook den Stream nie blockiert. Warten mehr als 50 Meldungen, fällt die älteste weg.
- **Beachtet 429.** Discord beantwortet Bursts mit `429` und einem Wert `retry_after` in Sekunden im JSON-Body. Der Bot wartet so lange und versucht es erneut, höchstens dreimal.
- **Keine Pings.** `allowed_mentions: { parse: [] }` verhindert, dass ein Team- oder Spielername jemanden im Kanal erwähnt.
## Schritt 4 — Starten und testen
```bash
node discord-picks-bot.mjs
```
Im Testmodus sieht eine Meldung so aus:
```text
[dry run] 📉 Udinese v Fiorentina | **Udinese** (spread +0.25) | Pinnacle 1.88 → 1.70 (−9.6%) | Fair now 1.75 · max stake 150
```
In Discord ist dieselbe Meldung ein Embed: das Spiel als Titel, Seite und Quotenbewegung im Text, die faire Quote ohne Marge und der Maximaleinsatz in der letzten Zeile sowie Sportart, Liga und der Hinweis „18+ · not a tip" in der Fußzeile.
Steuere die Menge über Umgebungsvariablen, etwa `MIN_DROP=0.08` für weniger, stärkere Meldungen oder `MIN_STAKE=500` für nur tiefere Märkte.
## Schritt 5 — Dauerhaft betreiben
- Betreibe ihn mit `systemd`, `pm2` oder einem Container mit Neustart bei Fehlern. Der Bot verbindet sich mit Backoff selbst neu und baut seine Eventliste aus dem neuen Snapshot wieder auf.
- Ein Webhook pro Kanal reicht. Willst du Fußball und Tennis in getrennten Kanälen, starte zwei Kopien mit anderen `sports` und Webhooks; ein Builder-Schlüssel erlaubt 3 WebSocket-Verbindungen.
- Führe die Bilanz ehrlich: Protokolliere jede Meldung und miss sie mit dem [Closing Line Value](/de/guides/closing-line-value-clv-tracking) statt mit der Trefferquote.
- Was man in einem Server postet und wie man ihn moderiert, beschreibt der [Anwendungsfall Discord-Server](/use-cases/discord-servers) (auf Englisch).
## Häufige Fragen
### Welchen PinnFeed-Plan braucht der Discord-Bot?
Builder (99 €/Monat) oder höher, weil er den WebSocket liest. Zum Vergleich siehe die Seite zum [Preis des WebSockets für Live und Pre-Match](/de/cheapest-pinnacle-odds-websocket). Bezahlte Pläne haben eine kostenlose Testphase von 3 Tagen; eine Karte ist nötig und wird nach Tag 3 belastet, sofern du nicht kündigst.
### Läuft er im Free-Plan?
So nicht. Free ist nur REST mit 30 Sekunden Verzögerung. Für einen langsameren Bot mit Free oder Hobby fragst du `/v1/drops` einmal pro Minute ab und postest das Ergebnis an denselben Webhook; siehe die [REST-Dokumentation](/docs) (auf Englisch).
### Brauche ich einen Discord-Bot-Account oder discord.js?
Nein. Ein eingehender Webhook nimmt einen einfachen JSON-`POST` an, der Bot braucht also nur `fetch`. Einen Bot-Account mit discord.js brauchst du nur für Slash-Befehle oder Antworten.
### Wie verhindere ich, dass der Kanal überläuft?
Erhöhe `MIN_DROP` oder `MIN_STAKE`, verkleinere `sports` und behalte die Sperrzeit pro Ausgang (eine Meldung pro Marktseite je `WINDOW_MS`). Das Limit der Warteschlange verwirft alte Meldungen, statt sie verspätet zu posten.
### Ist es erlaubt, Picks in einem Discord-Server zu posten?
Die Regeln für Wett-Tipps und Glücksspielwerbung unterscheiden sich von Land zu Land; in Deutschland regelt etwa der Glücksspielstaatsvertrag 2021 auch die Werbung für Sportwetten. Discord hat außerdem eigene Community-Richtlinien. Prüfe die Regeln dort, wo du und deine Mitglieder seid, halte den Server ab 18 und stelle Meldungen nie als sichere Gewinne dar. Das ist keine Rechtsberatung.