Real-time koersen streamen van Binance naar je lokale machine

Alex de Vries

Quantitatief Analist & Algo-Trading Expert

Brokers & API Integraties · 2026-02-15 · 8 min leestijd

Stel je voor: je zit achter je scherm, je Python-bot draait, en je ziet live de Bitcoin-prijs bewegen zonder dat je F5 hoeft te drukken. Je krijgt elke tick binnen, direct op je eigen harde schijf.

Dat is het verschil tussen gokken op een oude screenshot en handelen met echte data. Je wilt die stroom van koersen gewoon naar je lokale machine halen. Waarom? Omdat je backtests en risicomanagement alleen werken als je data klopt.

En omdat je bot sneller moet zijn dan de markt. Binance is daarbij je bron.

Je haalt de koersen eruit, streamt ze naar je eigen omgeving en bouwt daarop verder. Dit is de basis van elke serieuze algoritmische trading setup. Je bent geen toerist meer; je bent een operator.

Wat is een real-time koersstream eigenlijk?

Een real-time koersstream is een doorlopende lijst van marktveranderingen die direct naar je toekomt.

Bij Binance gaat het om WebSocket-verbindingen die elke wijziging in de orderbook of elke nieuwe trade sturen. Je krijgt dan geen statisch CSV’tje, maar een levende datastroom. Je kunt die opslaan in een lokaal bestand, in een database, of meteen verwerken in je trading-bot.

Je hoeft niet elke seconde te pollen; de beurs stuurt het zelf naar je toe. Dat bespaart tijd, geld en fouten.

Je ontvangt bijvoorbeeld elke tick van BTC/EUR, met prijs, volume en timestamp.

Je kunt die data later gebruiken voor backtesting, voor risicomanagement en voor live beslissingen. Zo wordt een stream de motor achter je algoritmische strategie. Veel traders beginnen met Excel of een simpele script-poll, maar dat is traag en onbetrouwbaar. Een WebSocket is sneller en lichter.

Je bouwt een kleine listener die binnenkomende berichten verwerkt. Je kunt kiezen voor de public streams (geen API-sleutel nodig) of voor private streams (met sleutel) voor je eigen orders.

Je kunt ook meerdere paren tegelijk volgen, zoals BTC/EUR, ETH/EUR en SOL/EUR. Je bepaalt zelf hoeveel data je opslaat. Je kunt raw ticks opslaan of alvast aggregaten naar 1-minuut candles. Zo blijft je schijfruimte beheersbaar en je pipeline snel.

Waarom wil je dit naar je eigen machine halen?

Je wilt controle. Je wilt dat je data onafhankelijk is van externe dashboards en dat je ze kunt analyseren zoals jij wilt. Je wilt snelle backtests op je eigen hardware draaien, zonder wachtrijen.

Je wilt risicomanagement bouwen op basis van jouw definities, niet die van een platform.

Je wilt latency minimaliseren: hoe dichter bij de bron, hoe sneller je bot kan reageren. Je wilt ook privacy: je handelsstrategie blijft lokaal.

Je bespaart kosten: lokale opslag is goedkoper dan dure cloud-queues op lange termijn. Je kunt experimenteren zonder productie-risico: je draait een teststraam naast je live-omgeving. En je kunt altijd teruggrijpen naar ruwe data voor herstel of audit.

Je zult merken dat een lokale setup je leercurve versnijdt. Je ziet direct wat er misgaat als een verbinding wegvalt.

Je ontdekt hoe je bufferen moet en hoe je herstelt na een onderbreking. Je bouwt robuustheid in, zoals heartbeat-checks en reconnect-strategieën. Je kunt data combineren met externe bronnen, zoals nieuwsfeeds of orderbook-snapshots. Je kunt ook je broker-API koppelen, bijvoorbeeld via een wrapper als ccxt, om orders te plaatsen op basis van je stream.

Je houdt alles onder één dak: data, strategie, backtest en risico. Dat voelt als sturen met een dashboard dat je zelf gebouwd hebt, niet met een huurauto.

Hoe werkt het: stappenplan en code-voorbeeld

Je begint met een Python-omgeving. Gebruik Python 3.10 of nieuwer.

Installeer een paar libraries: websocket-client, pandas en eventueel ccxt voor broker-integratie. Je kunt ook een event-driven framework gebruiken, maar je kunt ook simpel beginnen. Je kiest een Binance WebSocket-stream.

Voor spot-markt is de endpoint wss://stream.binance.com:9443/ws. Je abonneert je op een stream zoals "btc-eur@trade" of "btc-eur@depth".

Zorg dat je API-sleutels veilig zijn. Gebruik environment variables en commit geen keys naar Git.

Je kunt meerdere streams combineren via de stream-naam-array. Je schrijft een callback die binnenkomende berichten verwerkt. Je slaat ze op in een JSON- of CSV-bestand, of in een lichte database.

Je bouwt een kleine buffer om pieken op te vangen. Je voegt een heartbeat toe om te checken of de verbinding leeft.

Je test met een testaccount en met een kleine inleg, bijvoorbeeld €50, om latency te meten zonder groot risico.

import json
import websocket
import pandas as pd
from datetime import datetime

def on_message(ws, message):
    data = json.loads(message)
    # Bij 'trade' stream: { "e":"trade", "p":"42000.00", "q":"0.001", "T":1234567890123 }
    if "e" in data and data["e"] == "trade":
        row = {
            "timestamp": datetime.utcfromtimestamp(data["T"] / 1000),
            "price": float(data["p"]),
            "quantity": float(data["q"]),
        }
        df = pd.DataFrame([row])
        df.to_csv("btc_eur_trades.csv", mode="a", header=False, index=False)
        print(f"Trade: {row['price']} @ {row['timestamp']}")

def on_error(ws, error):
    print("Error:", error)

def on_close(ws, close_status_code, close_msg):
    print("Connection closed")

def on_open(ws):
    print("Connected")
    # Abonneer op BTC/EUR trades en depth
    ws.send(json.dumps({
        "method": "SUBSCRIBE",
        "params": ["btc-eur@trade", "btc-eur@depth"],
        "id": 1
    }))

if __name__ == "__main__":
    ws = websocket.WebSocketApp(
        "wss://stream.binance.com:9443/ws",
        on_open=on_open,
        on_message=on_message,
        on_error=on_error,
        on_close=on_close,
    )
    ws.run_forever()

Begin met dit Python-voorbeeld (vereist: websocket-client): Dit script opent een WebSocket, abonneert zich op trades en depth voor BTC/EUR en schrijft elke trade naar een CSV. Je kunt dit uitbreiden naar meerdere paren. Je kunt ook candles streamen via de Kline-stream.

Je kunt de CSV later inladen voor backtesting met pandas. Je kunt een event-driven architectuur bouwen voor complexere strategieën, met queues en actors.

Je kunt ook een database gebruiken, zoals SQLite voor eenvoud of TimescaleDB voor tijdseries. Je kunt latency meten door timestamps te vergelijken met je systeemklok. Je kunt een buffer bouwen die data batch-verwerkt als je schijf te traag wordt. Je kunt ook compressie toepassen op oude data om schijfruimte te besparen.

Varianten: public vs private, lokaal vs cloud, en kosten

Je hebt verschillende varianten. Public streams: trades, depth, klines.

Die zijn gratis en vereisen geen API-sleutel. Private streams: je eigen orders, account-updates. Die vereisen een API-sleutel en een handtekening.

Je kunt kiezen voor een enkele stream of voor een combined stream met meerdere paren in één verbinding. Je kunt lokaal draaien op je laptop of op een Raspberry Pi voor lage stroomkosten.

Je kunt ook een VPS nemen dicht bij Binance-datacenters, bijvoorbeeld in Europa of Azië, om latency te verlagen.

Je kunt cloud-queues gebruiken, zoals AWS SQS, maar dat kost geld en voegt complexiteit toe. Je kunt ook een managed service nemen, maar dan ben je je onafhankelijkheid kwijt. Kosten: een VPS van €5-€15 per maand is genoeg voor één of twee streams. Een Raspberry Pi 4 kost ongeveer €60 en verbruikt weinig stroom.

Opslag: een 256 GB SSD kost €30-€40, genoeg voor maanden aan tickdata. Backtesting met pandas is gratis, tenzij je een professioneel framework wilt gebruiken, dat kan €50-€200 per maand kosten.

Risicomanagement kun je zelf bouwen, of je kiest voor een tool als QuantConnect, maar dan ben je weer afhankelijk. Je kunt ook een broker-API koppelen via ccxt, waarmee je orders kunt plaatsen op basis van je stream. Je betaalt dan transactiekosten, bijvoorbeeld 0,1% bij Binance, en soms extra voor market data.

Public streams: gratis, geen sleutel nodig.
Private streams: sleutel nodig, veilig opslaan.
Lokaal: volledige controle, lage latency.
Cloud: schaalbaar, maar duurder en complexer.
VPS: goedkoper dan cloud, dichter bij de beurs.

Je kunt ook een demo-account gebruiken om te testen zonder echt geld.

Je kunt modellen vergelijken voor datavolume. Een enkele trade-stream voor BTC/EUR levert ongeveer 10-50 messages per seconde, afhankelijk van marktactiviteit. Een depth-stream kan 100-500 messages per seconde zijn.

Je kunt dieper gaan met level-2 orderbook, maar dat is zwaarder. Je kunt ook candles streamen, bijvoorbeeld 1-minuut, wat veel minder data geeft.

Je kunt je opslag plannen: ruwe tickdata is groter, aggregated candles zijn kleiner. Je kunt compressie toepassen, zoals gz, om ruimte te besparen. Je kunt ook een retention-beleid instellen: na 30 dagen archiveer je oude data naar een externe schijf.

Praktische tips voor een stabiele setup

Begin klein. Pak één paar, bijvoorbeeld BTC/EUR, en bouw je pipeline.

Test met een demo-account. Gebruik een API-sleutel met minimale rechten. Sla je sleutels op in een .env-bestand en laad ze met python-dotenv.

Gebruik een heartbeat: Binance stuurt geen ping, dus je kunt een timer bouwen die elke 30 seconden een ping stuurt en reconnect bij uitval.

Zet een buffer tussen je listener en je opslag om pieken op te vangen. Log fouten en herstelautomatisch. Monitor je schijfruimte en je netwerk.

Zet een firewall op je VPS en beperk toegang. Gebruik gzip voor oude data.

Test je backtests op een subset van data voordat je volledige datasets draait.

Bouw risicomanagement in. Stel limieten in voor je bot: maximale positie, dagelijkse drawdown, en kill-switch bij verlies van bijvoorbeeld €200. Gebruik een stop-loss en een take-profit, en test die op historische data. Gebruik een simulator voor je orderuitvoer, zodat je weet hoe slippage werkt.

Gebruik een broker-API voor live orders, maar begin met een kleine inleg, bijvoorbeeld €100. Je kunt ook een trading bot bouwen die alleen long gaat bij sterke trends, of die arbitrage zoekt tussen paren.

Installeer Python en libraries: websocket-client, pandas, ccxt.
Sla je API-sleutel veilig op in .env.
Kies een stream: bijvoorbeeld btc-eur@trade.
Start je script en monitor de output.
Sla data op in CSV of database.
Bouw een backtest op de opgeslagen data.
Test je bot met een demo-account en kleine inleg.
Voeg risicomanagement toe: limieten en kill-switch.
Monitor en verbeter: latency, opslag, fouten.

Je kunt een backtest draaien op 6 maanden data en je winst/verlies berekenen. Je kunt je resultaten vergelijken met een benchmark, zoals BTC-hold. Je kunt je risico verlagen door te diversifiëren over meerdere paren.

Je bent nu klaar om live te gaan. Je kunt je setup uitbreiden naar meerdere paren, naar private streams, en naar een echte broker-API voor orderuitvoer.

Je kunt je pipeline optimaliseren met caching en compressie, en voorkomen dat je rate limits overschrijdt. Je kunt je backtests versnellen met parallelle verwerking. Je kunt je risicomanagement aanscherpen met statistieken zoals Sharpe en max drawdown.

Je kunt je bot laten draaien op een VPS, met monitoring en alerts.

Je kunt je resultaten delen met een kleine community, of gewoon voor jezelf houden. Je hebt nu een echte, lokale real-time koersstream van Binance. En je weet hoe je die gebruikt voor algoritmische trading, backtesting, brokers en risicomanagement.