Traden met API via Bybit: complete gids voor 2026

Kort antwoord: de nieuwe Bybit EU-uitleg over de handels-API staat online, maar de officiële communicatie volgt nog. Gebruik deze gids intussen om een veilige koppeling voor te bereiden en de volledige technische werkwijze te begrijpen. Beschouw de pagina niet als bewijs dat jouw account al toegang heeft. Controleer na de officiële communicatie welke route Bybit EU in jouw account aanbiedt. Krijg je bij het maken van een sleutel foutcode 81007, dan wordt die aanmaakroute niet door Bybit Europe ondersteund.

Je kunt de voorbereiding doen zonder op de officiële communicatie vooruit te lopen. Richt een lokaal Pythonproject in, houd sleutels buiten de broncode, bouw controles voor bedragen en instrumentregels en leg vast hoe je een koppeling direct uitschakelt. Wacht met accountgebonden authenticatie en orderverzending totdat Bybit EU de officiële communicatie heeft vrijgegeven en de juiste route in jouw eigen account zichtbaar is.

Werk je met een AI-code-assistent, houd de opdracht dan klein en controleer iedere wijziging. Onze beginnersgids voor vibe coding laat zien hoe je met een plan, tests en een diff-review werkt zonder sleutels of echte orders in een oefenproject te gebruiken.

Een API kan een handelsproces sneller en consistenter maken, maar maakt een strategie niet winstgevend. Bij slechte invoer, te ruime rechten of gebrekkige foutafhandeling kan de software dezelfde fout bij iedere nieuwe order herhalen. Controleer daarom eerst de toegang en beveiliging. Begin pas daarna aan de verbinding, de Pythoncode en een eventuele eerste order.

Kun je vanuit Nederland via de Bybit API traden?

Dat hangt voorlopig af van de Bybit-entiteit, je account en de koppeling die in dat account beschikbaar komt. De nieuwe Bybit EU-helpartikelen beschrijven ondersteunde API-functies. Bybits algemene helpcentrum legt daarnaast uit hoe een bestaande sleutel wordt verwijderd. Bybit heeft CryptoFocus laten weten dat de officiële communicatie over de introductie nog volgt. De algemene V5-integratiegids zegt bovendien dat het EU-serveradres alleen de functie Connect to Third-Party Applications (koppelen met externe toepassingen) ondersteunt voor API-brokergebruikers. De V5-foutcodetabel vermeldt 81007 voor een poging om via Bybit Europe een API-sleutel aan te maken.

Daarom behandelen we 81007 niet als bewijs dat geen enkele API-koppeling op ieder EU-account kan bestaan. De code betekent wel dat je niet mag aannemen dat de gewone, zelf aangemaakte V5-sleutel uit een wereldwijde handleiding op jouw EU-account beschikbaar is. Product, land, accounttype en gekozen Bybit-entiteit bepalen samen wat je kunt gebruiken.

Zie je in je Bybit EU-account geen ondersteunde koppeling, dan is dat geen programmeerprobleem dat je met een ander serveradres of een VPN moet omzeilen. Gebruik nooit een API-adres van een andere entiteit om een regionale beperking te passeren.

Start hier: kies eerst de juiste route

Volg niet meteen de code. Bepaal eerst welke van deze twee routes bij jouw account hoort:

1. Controleer waar je bent ingelogd. Kijk naar het domein in de adresbalk en naar de juridische entiteit in je account. bybit.eu, bybit.nl, de wereldwijde site en de testomgeving (testnet) zijn niet onderling uitwisselbaar.
2. Open het API-beheer vanuit het profielmenu. Verschijnt alleen een ondersteunde partner- of externe-appkoppeling, volg dan die EU-route. Kopieer geen stappen voor een handmatige V5-sleutel uit een andere regionale handleiding.
3. Zie je een officiële mogelijkheid om zelf een V5-sleutel te maken? Controleer dan of die functie voor jouw land, account en gewenste product is toegestaan. Pas daarna gebruik je de technische oefening in deze gids.
4. Krijg je foutcode 81007? Stop de handmatige sleutelroute. Gebruik alleen een alternatief dat Bybit zelf in jouw account toont of vraag de klantenservice van Bybit welke ondersteunde koppeling voor jouw account geldt.

Wat is traden met API?

API staat voor application programming interface. Het is een afgesproken manier waarop twee softwaresystemen met elkaar communiceren. In plaats van op de koopknop te drukken, stuurt jouw programma bijvoorbeeld een gestructureerd verzoek: koop een bepaalde hoeveelheid van een toegestaan handelspaar met een limietorder. De beurs antwoordt met een status, ordernummer of foutcode.

In de praktijk werk je met REST, WebSocket en een eigen controlelaag:

1. REST voor gerichte verzoeken. Je vraagt een instrument op, leest een saldo, plaatst een order of annuleert die. Iedere actie heeft een API-adres, een verzoekmethode en parameters.
2. WebSocket voor doorlopende meldingen. Je ontvangt koers-, order- en uitvoeringsberichten zodra er iets verandert. Dat voorkomt dat je voortdurend dezelfde REST-vraag herhaalt.
3. Jouw eigen controlelaag. De strategie, positielimieten, logboeken, foutafhandeling, afstemming van administraties en noodstop draaien buiten de beurs. Deze laag bepaalt of automatisering beheersbaar blijft.

De API vormt het transportkanaal. Jouw software bepaalt de strategie en moet een verkeerd signaal tegenhouden.

Wat een handels-API voor crypto doet

Via de API kan jouw software actuele markt- en instrumentgegevens ophalen, ondersteunde orders plaatsen of annuleren en de status van orders en uitvoeringen volgen. Daardoor kan dezelfde handelsregel telkens op dezelfde manier worden toegepast.

De verbinding voorspelt geen koers en garandeert geen uitvoering. Het bied-laatverschil (spread), prijsafwijking tijdens de uitvoering (slippage) en handelskosten blijven bestaan. Ook een regionale of accountgebonden beperking blijft gelden, ongeacht wat de code technisch kan versturen.

API, handelsbot, webhook of ingebouwde bot: wat is het verschil?

Deze begrippen worden vaak door elkaar gebruikt, maar ze beschrijven verschillende onderdelen.

• API: de technische verbinding met de beurs.
• Handelsbot: software die handelsregels uitvoert en daarvoor vaak een API gebruikt.
• Webhook: een bericht van het ene systeem naar het andere, bijvoorbeeld een TradingView-signaal naar een uitvoeringsdienst. Een webhook is geen volledige orderadministratie.
• Ingebouwde bot: automatisering die binnen het platform van de beurs draait. Je beheert dan meestal geen eigen API-sleutel of code.
• Externe toepassing of API-broker: een derde partij waaraan je via een ondersteunde toestemmingsprocedure beperkte toegang geeft.

Wil je producten vergelijken in plaats van de techniek begrijpen? Lees dan onze aparte gids over de beste handelsbots voor crypto. Die pagina behandelt de keuze tussen aanbieders. Deze gids gaat over toegang, bouwstenen, veiligheid en ordercontrole.

De Bybit EU-route: een externe toepassing veilig koppelen

Bybit beschrijft een API als een manier waarop software, afhankelijk van account en product, marktgegevens kan opvragen, accountinformatie kan lezen en ondersteunde orders kan indienen of annuleren. Zolang Bybit EU de officiële communicatie nog niet heeft vrijgegeven, is dit hoofdstuk een voorbereiding op de mogelijke accountstappen. Voor Bybit EU moet je uiteindelijk de route volgen die in je eigen account zichtbaar is. De algemene V5-integratiegids noemt voor het EU-serveradres de functie Connect to Third-Party Applications voor API-brokergebruikers. De nieuwe EU-helppagina’s beschrijven de handels-API en verwijzen naar documentatie. Dat verschil is precies waarom je de accountomgeving leidend moet maken.

De precieze schermen en beschikbare partners kunnen veranderen. Doorloop vóór iedere koppeling deze controle:

1. Controleer de entiteit. Kijk of je werkelijk bij Bybit EU bent ingelogd. Een handleiding voor de wereldwijde Bybit-site is geen bewijs dat dezelfde functie in de EU bestaat.
2. Open alleen de koppeling vanuit je account. Gebruik de officiële accountomgeving en zoek naar de ondersteunde optie voor externe toepassingen. Begin niet bij een willekeurige link die een aanbieder in een chatbericht stuurt.
3. Controleer de identiteit van de toepassing. Vergelijk naam, domein en omschreven dienst met de officiële informatie van Bybit en de aanbieder.
4. Lees ieder gevraagd recht. Een strategie die alleen spotorders uitvoert, hoort geen opname- of onnodige accountrechten te krijgen. Verschijnt een onverklaarbaar recht, stop dan.
5. Beperk de inzet. Begin met een klein afzonderlijk bedrag. Houd niet je volledige handelsvermogen in een experimentele automatisering.
6. Test één volledige cyclus. Controleer een order van aanvraag tot uitvoering, annulering en administratie. Een succesvolle API-reactie is niet hetzelfde als een gevulde order.
7. Controleer de intrekroute. Zorg vóór ingebruikname dat je weet waar je de toestemming of sleutel verwijdert.

Minimale beveiligingsregels

Beveilig zowel je beursaccount als het gekoppelde e-mailadres met tweefactorauthenticatie. Geef een toepassing alleen de rechten die zij nodig heeft en laat opnamerechten uit. Biedt de koppeling een IP-beperking, zet die dan aan voor de vaste adressen van je handelsserver.

Een sleutel of geheim hoort niet thuis in broncode, schermafbeeldingen, gesprekken met een helpdesk of AI-dienst, rekenbladen of openbare codearchieven. Bewaar geheimen in een daarvoor bestemde kluis of, voor een lokale proef, in tijdelijke omgevingsvariabelen. Verwijder ongebruikte toegang en stel waarschuwingen in voor onverwachte orders, mislukte authenticatie en uitval van marktgegevens.

De officiële Bybit-documentatie vinden, en waarom dat in de EU verwarrend is

Het nieuwe Bybit EU-helpartikel over het vinden van de API-documentatie verwijst naar eu-docs/fin. Bij onze controle op 25 augustus 2026 opende die verwijzing documentatie voor Open Banking en PSD2-diensten, zoals rekeninginformatie en betaalinitiatie. Dat is niet dezelfde documentatie als de handels-API voor crypto. Omdat Bybit het communicatiemateriaal nog juridisch laat beoordelen en de officiële communicatie nog niet heeft vrijgegeven, trekken we uit deze verwijzing nog geen conclusie over de definitieve handelsdocumentatie. We controleren dit onderdeel opnieuw zodra Bybit zijn officiële communicatie heeft vrijgegeven.

De algemene Bybit V5-integratiegids beschrijft marktgegevens, authenticatie en handelsfuncties. Die technische documentatie bewijst niet dat jouw Bybit EU-account er gebruik van mag maken. Gebruik het Bybit EU-helpcentrum voor Europese product- en accountbeschikbaarheid. Raadpleeg de algemene V5-documentatie als technische referentie wanneer je account aantoonbaar toegang heeft.

Controleer bij iedere koppeling de juiste entiteit, het serveradres, het accounttype, het product en de toestemming voor de gebruikte API-functie. Een voorbeeld met api-testnet.bybit.com zegt niets over toegang via Bybit EU.

Hoe authenticatie bij de algemene Bybit V5 API werkt

Openbare marktgegevens kunnen zonder privésleutel beschikbaar zijn. Voor accountinformatie en orderacties moet de server kunnen controleren wie het verzoek stuurt en of het onderweg is gewijzigd. Bybit beschrijft daarvoor HMAC- en zelf gegenereerde RSA-sleutels.

Bij een beveiligd verzoek worden onder meer deze HTTP-kopteksten gebruikt:

• X-BAPI-API-KEY: de publieke identificatie van de sleutel;
• X-BAPI-TIMESTAMP: het moment waarop het verzoek is gemaakt;
• X-BAPI-SIGN: de cryptografische handtekening;
• X-BAPI-RECV-WINDOW: de toegestane tijdsruimte, standaard 5.000 milliseconden volgens de integratiegids.

De privésleutel of het API-geheim zelf hoort nooit in het verzoek te staan. Je programma gebruikt het lokaal om de handtekening te maken. Bybit controleert vervolgens de handtekening en de tijd. Een verkeerd ingestelde systeemklok kan daarom foutcode 10002 opleveren. Synchroniseer productieservers met een betrouwbare tijdbron en maak het ontvangstvenster niet onnodig ruim.

HMAC of RSA?

Bij HMAC delen het programma en het platform een geheim. Bij RSA houd jij de privésleutel en deel je de publieke sleutel. RSA kan voor professionele infrastructuur aantrekkelijk zijn omdat de privésleutel jouw omgeving niet hoeft te verlaten. Welke methode je kunt gebruiken, hangt af van de beschikbare accountroute. Een complexere sleutelsoort maakt te ruime rechten of gebrekkige logboekregistratie niet veilig.

Python-oefening: van lege map naar werkende gegevensverbinding

Bybit onderhoudt de officiële Python-koppeling pybit. Installeer het pakket in een nieuwe virtuele omgeving. Zo blijven de onderdelen van deze oefening gescheiden van andere Python-projecten. De eerste test gebruikt openbare instrumentgegevens, vraagt geen API-sleutel en kan geen order plaatsen. De voorbeelden zijn op 25 augustus 2026 gecontroleerd met pybit 5.17.0, waarvoor Python 3.10 of nieuwer nodig is.

Stap 1: controleer Python

Open Terminal op macOS of Linux, of PowerShell op Windows. Controleer eerst of Python beschikbaar is:

# macOS of Linux
python3 --version

# Windows PowerShell
py --version

De versie moet 3.10 of hoger zijn. Werkt geen van beide opdrachten of zie je een lagere versie, installeer dan een actuele Python 3-versie via python.org en open daarna een nieuw terminalvenster. Laat Windows tijdens de installatie ook de Python-opdracht en het startprogramma toevoegen.

Stap 2: maak een aparte projectmap

Voer op macOS of Linux deze opdrachten één voor één uit:

mkdir bybit-api-oefening
cd bybit-api-oefening
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install "pybit==5.17.0"

Gebruik je Windows PowerShell, voer dan dit uit:

mkdir bybit-api-oefening
cd bybit-api-oefening
py -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install "pybit==5.17.0"

Na activering staat meestal (.venv) voor de opdrachtregel. Krijg je later de fout ModuleNotFoundError: No module named 'pybit', activeer deze omgeving opnieuw en voer de installatieopdracht nogmaals uit.

Blokkeert PowerShell alleen het activeringsbestand, geef dan uitsluitend voor het huidige PowerShell-venster toestemming en activeer de omgeving opnieuw:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\.venv\Scripts\Activate.ps1

Stap 3: vraag openbare instrumentregels op

Maak in de map bybit-api-oefening een bestand met de naam check_bybit.py en plak onderstaande code erin. Het voorbeeld gebruikt de algemene testomgeving en vraagt alleen instrumentinformatie op. Het bevat geen sleutel en geen order.

from pybit.unified_trading import HTTP

session = HTTP(testnet=True)

response = session.get_instruments_info(
    category="spot",
    symbol="BTCUSDT",
)

if response.get("retCode") != 0:
    raise RuntimeError(
        f"Bybit gaf fout {response.get('retCode')}: {response.get('retMsg')}"
    )

instruments = response.get("result", {}).get("list", [])
if not instruments:
    raise RuntimeError("BTCUSDT is niet gevonden in deze omgeving.")

instrument = instruments[0]
lot_size = instrument["lotSizeFilter"]
print({
    "symbol": instrument["symbol"],
    "tick_size": instrument["priceFilter"]["tickSize"],
    "base_precision": lot_size["basePrecision"],
    "min_order_amount": lot_size["minOrderAmt"],
    "max_limit_order_qty": lot_size["maxLimitOrderQty"],
})

Sla het bestand op en voer het uit vanuit dezelfde map:

python check_bybit.py

Bij een geslaagde test zie je een Python-woordenboek met onder meer BTCUSDT, de minimale prijsstap, de basisprecisie, het minimale orderbedrag en de maximale hoeveelheid voor een limietorder. De precieze waarden kunnen veranderen. Krijg je een netwerk- of regiomelding, wissel dan niet zelf van serveradres. Controleer eerst of de gebruikte omgeving voor jou is toegestaan.

Sla de instrumentregels niet over. Leg prijsstappen, hoeveelheidsprecisie en ordergrenzen niet als vaste getallen in de code vast. Bybit vermeldt dat bepaalde maximale orderhoeveelheden twee keer per maand kunnen worden aangepast. Vraag de actuele regels dus telkens op, rond voorzichtig af en controleer de order opnieuw voordat je hem verstuurt. Gebruik voor spotorders niet het verouderde veld minOrderQty als beslisregel; de huidige documentatie verwijst voor de ondergrens naar minOrderAmt.

Stap 4: maak alleen via een toegestane route een sleutel voor de testomgeving

Sla deze stap over als jouw account of regio de algemene V5-testomgeving niet toestaat. Volgens de algemene Bybit-handleiding zijn de testomgeving (testnet) en productieomgeving (mainnet) gescheiden. Je maakt een testaccount via een computerbrowser op testnet.bybit.com. Stort daar nooit echt geld.

1. Log in bij de testomgeving en open Assets en daarna Assets Overview.
2. Kies Request Test Coins. Bybit vermeldt dat je eenmaal per 24 uur testtegoeden kunt aanvragen.
3. Open vervolgens vanuit het profielmenu API of API Management. Het aanmaken van een sleutel gaat volgens Bybit alleen via de website.
4. Kies Create New Key (nieuwe sleutel maken), selecteer uitsluitend de rechten die voor de oefening nodig zijn en rond de tweefactorauthenticatie af.
5. Geef de sleutel geen opnamerechten. Bewaar sleutel en geheim niet in het Python-bestand.

Zie je deze schermen niet of krijg je 81007, stop dan. Dat is een toegangs- of accountroute, geen fout die je in Python kunt oplossen.

Stap 5: stel de testsleutel tijdelijk in

Voor een privéverzoek gebruikt de code omgevingsvariabelen. Vervang de tekst tussen aanhalingstekens uitsluitend door je eigen gegevens voor de testomgeving. Deel de echte waarden nooit in een schermafbeelding, gesprek, hulpverzoek of codearchief.

macOS of Linux:

export BYBIT_API_KEY='plak-hier-je-sleutel-voor-de-testomgeving'
export BYBIT_API_SECRET='plak-hier-het-bijbehorende-geheim'

Windows PowerShell:

$env:BYBIT_API_KEY='plak-hier-je-sleutel-voor-de-testomgeving'
$env:BYBIT_API_SECRET='plak-hier-het-bijbehorende-geheim'

Deze waarden gelden alleen voor het geopende terminalvenster. Sluit het venster na de oefening. Voor productie hoort een geheim in een beheerde geheimenkluis. Een lokaal .env-bestand is geen vereiste voor deze gids; wie het toch gebruikt, moet het uitsluiten in .gitignore, bestandsrechten beperken en voorkomen dat logboeken de inhoud tonen.

Onderstaande korte controle leest alleen accountinformatie en plaatst geen order. Sla de code op als check_account.py en voer python check_account.py uit:

import os
from pybit.unified_trading import HTTP

missing = [
    name
    for name in ("BYBIT_API_KEY", "BYBIT_API_SECRET")
    if not os.environ.get(name)
]
if missing:
    raise SystemExit("Ontbrekende omgevingsvariabelen: " + ", ".join(missing))

session = HTTP(
    testnet=True,
    api_key=os.environ["BYBIT_API_KEY"],
    api_secret=os.environ["BYBIT_API_SECRET"],
)

response = session.get_wallet_balance(accountType="UNIFIED")
if response.get("retCode") != 0:
    raise RuntimeError(
        f"Bybit gaf fout {response.get('retCode')}: {response.get('retMsg')}"
    )

print("Authenticatie gelukt; accountgegevens zijn ontvangen.")

Een Bybit-order veilig opbouwen

In de algemene V5-documentatie wordt een order geplaatst via POST /v5/order/create. Voor een spotlimietorder heb je onder meer de categorie, het symbool, de koop- of verkoopzijde, het ordertype, de hoeveelheid, de prijs en de geldigheidsduur nodig. Verstuur niet rechtstreeks wat een strategie berekent. Controleer de order eerst stap voor stap.

1. Lees instrumentregels. Haal voor een spotlimietorder onder meer tickSize, basePrecision, minOrderAmt en maxLimitOrderQty op. Derivaten gebruiken andere velden, waaronder qtyStep; neem veldnamen dus niet klakkeloos over tussen productcategorieën.
2. Lees een bruikbare prijs. Controleer hoe recent de marktgegevens zijn. Stop bij een te oude tijdstempel.
3. Bereken de gewenste order. Houd rekening met beschikbaar saldo, bestaande orders en posities.
4. Pas risicolimieten toe. Blokkeer bedragen boven het maximum per order, per munt en per dag.
5. Normaliseer prijs en hoeveelheid. Rond volgens de instrumentregels, niet volgens het aantal decimalen dat je toevallig ziet.
6. Ken een uniek orderkenmerk toe. Bybit ondersteunt orderLinkId tot 36 tekens en verlangt dat dit kenmerk uniek is.
7. Verzend één keer. Bij een time-out controleer je eerst of de order bestaat. Blind opnieuw sturen kan een dubbele order veroorzaken.
8. Bevestig via WebSocket. Een geslaagd REST-antwoord betekent alleen dat het verzoek is geaccepteerd. Bybit noemt de verwerking asynchroon en adviseert de orderstatus via WebSocket te bevestigen.
9. Vergelijk na afloop. Breng de lokale administratie, orderstatus en uitvoeringen met elkaar in overeenstemming. Een gedeeltelijk gevulde order vraagt een andere behandeling dan een volledig gevulde order.

Stap 6: bouw eerst een testorder zonder hem te versturen

Maak nu het bestand dry_run_order.py. Dit zelfstandige voorbeeld bouwt een order op, maar verstuurt hem standaard niet. Alleen de expliciete omgevingswaarde ALLOW_TESTNET_ORDER=yes geeft eenmalig toestemming om de order te versturen. Gebruik die waarde pas nadat je de instrumentregels, actuele prijs in de testomgeving en berekende order handmatig hebt gecontroleerd.

import os
import uuid
from decimal import Decimal, InvalidOperation
from pybit.unified_trading import HTTP

required = (
    "BYBIT_API_KEY",
    "BYBIT_API_SECRET",
    "TESTNET_ORDER_QTY",
    "TESTNET_LIMIT_PRICE",
    "TESTNET_MAX_ORDER_VALUE",
)
missing = [name for name in required if not os.environ.get(name)]
if missing:
    raise SystemExit("Ontbrekende omgevingsvariabelen: " + ", ".join(missing))

session = HTTP(
    testnet=True,
    api_key=os.environ["BYBIT_API_KEY"],
    api_secret=os.environ["BYBIT_API_SECRET"],
)

try:
    qty = Decimal(os.environ["TESTNET_ORDER_QTY"])
    price = Decimal(os.environ["TESTNET_LIMIT_PRICE"])
    max_order_value = Decimal(os.environ["TESTNET_MAX_ORDER_VALUE"])
except InvalidOperation:
    raise SystemExit(
        "Hoeveelheid, prijs en maximumbedrag moeten geldige decimale getallen zijn."
    )

if qty <= 0 or price <= 0 or max_order_value <= 0:
    raise SystemExit("Hoeveelheid, prijs en maximumbedrag moeten groter zijn dan nul.")

instrument_response = session.get_instruments_info(
    category="spot",
    symbol="BTCUSDT",
)
if instrument_response.get("retCode") != 0:
    raise RuntimeError(
        "Instrumentregels konden niet worden opgehaald: "
        f"{instrument_response.get('retCode')} "
        f"{instrument_response.get('retMsg')}"
    )

instruments = instrument_response.get("result", {}).get("list", [])
if not instruments:
    raise RuntimeError("BTCUSDT is niet gevonden in deze omgeving.")

instrument = instruments[0]
lot_size = instrument["lotSizeFilter"]
tick_size = Decimal(instrument["priceFilter"]["tickSize"])
qty_step = Decimal(lot_size["basePrecision"])
min_amount = Decimal(lot_size["minOrderAmt"])
max_limit_qty = Decimal(lot_size["maxLimitOrderQty"])

price_limit_response = session.get_price_limit(
    category="spot",
    symbol="BTCUSDT",
)
if price_limit_response.get("retCode") != 0:
    raise RuntimeError(
        "Actueel prijsbereik kon niet worden opgehaald: "
        f"{price_limit_response.get('retCode')} "
        f"{price_limit_response.get('retMsg')}"
    )
highest_buy_price = Decimal(price_limit_response["result"]["buyLmt"])

validation_errors = []
if price % tick_size:
    validation_errors.append(f"prijs is geen veelvoud van tickSize {tick_size}")
if qty % qty_step:
    validation_errors.append(
        f"hoeveelheid is geen veelvoud van basePrecision {qty_step}"
    )
if qty * price < min_amount:
    validation_errors.append(
        f"orderwaarde ligt onder minOrderAmt {min_amount} USDT"
    )
if qty > max_limit_qty:
    validation_errors.append(
        f"hoeveelheid ligt boven maxLimitOrderQty {max_limit_qty}"
    )
if price > highest_buy_price:
    validation_errors.append(
        f"koopprijs ligt boven het actuele buyLmt {highest_buy_price}"
    )
if qty * price > max_order_value:
    validation_errors.append(
        f"orderwaarde ligt boven je eigen maximum van {max_order_value} USDT"
    )
if validation_errors:
    raise SystemExit("Ongeldige testorder: " + "; ".join(validation_errors))

order = {
    "category": "spot",
    "symbol": "BTCUSDT",
    "side": "Buy",
    "orderType": "Limit",
    "qty": str(qty),
    "price": str(price),
    "timeInForce": "GTC",
    "orderLinkId": f"cf-oefening-{uuid.uuid4().hex[:20]}",
    "isLeverage": 0,
    "orderFilter": "Order",
}

if os.environ.get("ALLOW_TESTNET_ORDER") == "yes":
    result = session.place_order(**order)
    if result.get("retCode") != 0:
        raise RuntimeError(
            f"Bybit gaf fout {result.get('retCode')}: {result.get('retMsg')}"
        )
    print({
        "retCode": result.get("retCode"),
        "orderId": result.get("result", {}).get("orderId"),
        "orderLinkId": order["orderLinkId"],
    })
else:
    print("PROEF ZONDER VERZENDING:", order)

Het programma haalt ook het actuele prijsbereik op via GET /v5/market/price-limit. Omdat dit voorbeeld alleen een kooporder bouwt, weigert het een prijs boven buyLmt, de hoogste toegestane biedprijs die Bybit terugstuurt. Behandel foutcode 110003 altijd als een afwijzing, niet als reden om dezelfde order te blijven herhalen.

Stel eerst de testwaarden in. Kies een hoeveelheid die voldoet aan de zojuist opgehaalde instrumentregels en een limietprijs die je zelf in de testomgeving hebt gecontroleerd. Vul bij TESTNET_MAX_ORDER_VALUE een bovengrens in USDT in. Het programma weigert een order die daarboven uitkomt.

macOS of Linux:

export TESTNET_ORDER_QTY='vul-een-geldige-testhoeveelheid-in'
export TESTNET_LIMIT_PRICE='vul-een-gecontroleerde-limietprijs-in'
export TESTNET_MAX_ORDER_VALUE='vul-je-maximale-orderwaarde-in-usdt-in'
python dry_run_order.py

Windows PowerShell:

$env:TESTNET_ORDER_QTY='vul-een-geldige-testhoeveelheid-in'
$env:TESTNET_LIMIT_PRICE='vul-een-gecontroleerde-limietprijs-in'
$env:TESTNET_MAX_ORDER_VALUE='vul-je-maximale-orderwaarde-in-usdt-in'
python dry_run_order.py

De uitvoer moet beginnen met PROEF ZONDER VERZENDING. Controleer symbool, zijde, hoeveelheid en prijs. Wil je daarna bewust één order in de testomgeving versturen, gebruik dan de opdracht voor jouw systeem:

# macOS of Linux: toestemming geldt alleen voor deze ene opdracht
ALLOW_TESTNET_ORDER='yes' python dry_run_order.py

# Windows PowerShell: verwijdert de toestemming ook als Python een fout geeft
$env:ALLOW_TESTNET_ORDER='yes'
try { python dry_run_order.py }
finally { Remove-Item Env:ALLOW_TESTNET_ORDER -ErrorAction SilentlyContinue }

De uitvoer bevat de echte orderId en orderLinkId van deze testorder. Kopieer de orderLinkId; je hebt die in de volgende stap nodig. Een teruggestuurd nummer bewijst alleen dat Bybit het verzoek heeft geaccepteerd, niet dat de order is uitgevoerd.

Stap 7: controleer de status en annuleer een openstaande testorder

Maak in dezelfde map het bestand control_test_order.py. Het zoekt eerst in de actuele ordergegevens en daarna in de ordergeschiedenis. Met de opdracht status lees je de toestand; met cancel vraag je annulering aan. Bybit verwerkt ook een annulering asynchroon. Voer daarom na het annuleringsverzoek opnieuw status uit totdat je Cancelled, Filled of een andere eindstatus ziet.

import os
import sys
from pybit.unified_trading import HTTP

required = ("BYBIT_API_KEY", "BYBIT_API_SECRET", "TESTNET_ORDER_LINK_ID")
missing = [name for name in required if not os.environ.get(name)]
if missing:
    raise SystemExit("Ontbrekende omgevingsvariabelen: " + ", ".join(missing))

if len(sys.argv) != 2 or sys.argv[1] not in {"status", "cancel"}:
    raise SystemExit("Gebruik: python control_test_order.py status|cancel")

action = sys.argv[1]
order_link_id = os.environ["TESTNET_ORDER_LINK_ID"]
session = HTTP(
    testnet=True,
    api_key=os.environ["BYBIT_API_KEY"],
    api_secret=os.environ["BYBIT_API_SECRET"],
)

def require_ok(response, description):
    if response.get("retCode") != 0:
        raise RuntimeError(
            f"{description}: fout {response.get('retCode')} - {response.get('retMsg')}"
        )
    return response

def find_order():
    current = require_ok(
        session.get_open_orders(
            category="spot",
            symbol="BTCUSDT",
            orderLinkId=order_link_id,
        ),
        "Actuele ordergegevens konden niet worden opgehaald",
    )
    orders = current.get("result", {}).get("list", [])
    if orders:
        return orders[0]

    history = require_ok(
        session.get_order_history(
            category="spot",
            symbol="BTCUSDT",
            orderLinkId=order_link_id,
        ),
        "Ordergeschiedenis kon niet worden opgehaald",
    )
    orders = history.get("result", {}).get("list", [])
    return orders[0] if orders else None

if action == "cancel":
    response = require_ok(
        session.cancel_order(
            category="spot",
            symbol="BTCUSDT",
            orderLinkId=order_link_id,
        ),
        "Annuleren is niet gelukt",
    )
    print("Annuleringsverzoek geaccepteerd:", response.get("result", {}))
    print("Controleer de eindstatus opnieuw met de opdracht status.")
else:
    order = find_order()
    if not order:
        raise SystemExit(
            "Order nog niet gevonden. Wacht kort en probeer opnieuw; verstuur geen tweede order."
        )
    print({
        "orderId": order.get("orderId"),
        "orderLinkId": order.get("orderLinkId"),
        "status": order.get("orderStatus"),
        "aangevraagd": order.get("qty"),
        "uitgevoerd": order.get("cumExecQty"),
        "gemiddelde_prijs": order.get("avgPrice"),
        "resterend": order.get("leavesQty"),
    })

Stel nu de gekopieerde orderLinkId in en controleer de status:

# macOS of Linux
export TESTNET_ORDER_LINK_ID='plak-hier-de-teruggestuurde-orderLinkId'
python control_test_order.py status

# Alleen als de order nog openstaat en je hem wilt annuleren
python control_test_order.py cancel
python control_test_order.py status

# Windows PowerShell
$env:TESTNET_ORDER_LINK_ID='plak-hier-de-teruggestuurde-orderLinkId'
python control_test_order.py status

# Alleen als de order nog openstaat en je hem wilt annuleren
python control_test_order.py cancel
python control_test_order.py status

Kan de order al geheel of gedeeltelijk zijn uitgevoerd, controleer dan ook de uitvoering en het testsaldo. Alleen een nog niet of gedeeltelijk gevulde order kan worden geannuleerd; een al uitgevoerd deel wordt niet teruggedraaid. De algemene demo-omgeving ondersteunt niet alle API-functies. Werking in testnet of demo bewijst evenmin dat Bybit EU dezelfde route voor jouw account toestaat.

Markt- en limietorders: GTC, IOC, FOK en PostOnly

Een ordertype is geen detail. Het bepaalt welke prijszekerheid je opgeeft en hoe je handelsprogramma zich gedraagt als liquiditeit ontbreekt.

Voor een eerste oefening is een kleine spotlimietorder zonder hefboom overzichtelijker dan een marktorder of derivatenpositie. Dat is geen handelsadvies, maar een manier om minder variabelen tegelijk te testen.

WebSocket: wanneer een geaccepteerde order nog niet klaar is

Een betrouwbaar handelsprogramma gebruikt REST om een actie aan te vragen en WebSocket om veranderingen te volgen. In de besloten orderstroom ontvang je wijzigingen in de orderstatus. De uitvoeringsstroom bevat de daadwerkelijke uitvoeringen, inclusief prijs en hoeveelheid.

Een gedeeltelijke uitvoering is de normale eerste valkuil: één order kan uit meerdere deeluitvoeringen bestaan. Bereken de gemiddelde prijs en totale kosten dus uit de uitvoeringen, niet uit de gevraagde limietprijs.

Ook annuleren en uitvoeren kunnen elkaar kruisen. Bybit waarschuwt dat dan twee berichten met status Filled kunnen verschijnen. Zorg daarom dat hetzelfde bericht nooit tweemaal in de positie of het resultaat wordt verwerkt. De uitvoeringsstroom kan meerdere uitvoeringen in één bericht bevatten. Verwerk ieder onderdeel en ontdubbel op execId.

Bewaar lokaal minimaal het strategie-ID, orderLinkId, Bybit orderId, iedere execId, de status, aangevraagde en gevulde hoeveelheid, gemiddelde uitvoeringsprijs, kosten en tijdstippen. Haal na een verbroken verbinding via REST de actuele toestand op voordat je nieuwe orders toestaat.

Volg order- en uitvoeringsberichten in Python

Maak het bestand watch_test_orders.py. Dit programma plaatst en annuleert niets; het luistert alleen naar berichten van het testaccount. Start het vóór een volgende orderproef in een tweede terminalvenster. Activeer daar opnieuw .venv en stel de twee omgevingsvariabelen uit stap 5 opnieuw in.

import os
import time
from pybit.unified_trading import WebSocket

missing = [
    name
    for name in ("BYBIT_API_KEY", "BYBIT_API_SECRET")
    if not os.environ.get(name)
]
if missing:
    raise SystemExit("Ontbrekende omgevingsvariabelen: " + ", ".join(missing))

stream = WebSocket(
    testnet=True,
    channel_type="private",
    api_key=os.environ["BYBIT_API_KEY"],
    api_secret=os.environ["BYBIT_API_SECRET"],
)

def show_orders(message):
    for order in message.get("data", []):
        print("ORDER", {
            "orderId": order.get("orderId"),
            "orderLinkId": order.get("orderLinkId"),
            "status": order.get("orderStatus"),
            "aangevraagd": order.get("qty"),
            "uitgevoerd": order.get("cumExecQty"),
        })

def show_executions(message):
    for execution in message.get("data", []):
        print("UITVOERING", {
            "execId": execution.get("execId"),
            "orderId": execution.get("orderId"),
            "orderLinkId": execution.get("orderLinkId"),
            "prijs": execution.get("execPrice"),
            "hoeveelheid": execution.get("execQty"),
            "kosten": execution.get("execFee"),
        })

stream.order_stream(callback=show_orders)
stream.execution_stream(callback=show_executions)

print("Luistert naar testberichten. Stop met Ctrl+C.")
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    print("Luisteren gestopt.")

Start de luisteraar met python watch_test_orders.py. Plaats vervolgens vanuit het eerste terminalvenster hoogstens één gecontroleerde testorder. Controleer of de orderLinkId in beide vensters overeenkomt. Verschijnt geen bericht, verstuur dan geen tweede order: lees eerst met control_test_order.py status wat Bybit heeft opgeslagen.

Snelheidslimieten en zorgvuldige foutafhandeling

Een API heeft snelheidslimieten om systemen te beschermen. De algemene Bybit V5-documentatie noemt standaard 600 HTTP-verzoeken per vijf seconden per IP, plus aparte limieten per API-functie en gebruikersnummer. De grens voor het plaatsen van een order verschilt in de actuele tabel per productcategorie en accounttype. Neem daarom geen vast getal uit een voorbeeld over en behandel de toegestane grens nooit als streefwaarde.

Lees daarom bij ieder antwoord de HTTP-kopteksten X-Bapi-Limit-Status, X-Bapi-Limit en X-Bapi-Limit-Reset-Timestamp. Krijg je foutcode 10006, dan heb je de API-limiet overschreden. Bij een HTTP 403 wegens te veel IP-verkeer adviseert Bybit de HTTP-sessies te stoppen en minstens tien minuten te wachten.

Niet iedere fout mag automatisch opnieuw

Snelle oplossingen bij de eerste installatie

• python of py wordt niet gevonden: installeer Python 3, open een nieuw terminalvenster en herhaal de versiecontrole.
• ModuleNotFoundError: No module named 'pybit': activeer .venv opnieuw en voer python -m pip install "pybit==5.17.0" uit. Gebruik voor installeren en starten dezelfde Python-omgeving.
• De instrumentlijst is leeg: controleer category, symbol en de gekozen omgeving. Laat de code eerst het volledige antwoord tonen voordat je velden probeert uit te lezen.
• 10003: sleutel, test- of productieomgeving en domein passen niet bij elkaar. Probeer niet op goed geluk een ander regionaal serveradres; controleer de officiële accountomgeving.
• 10004: de handtekening klopt niet. Controleer of je sleutel en geheim volledig en zonder extra spaties zijn ingevoerd. De officiële programmabibliotheek (SDK) verzorgt de ondertekening; leg het geheim nooit vast om de fout te zoeken.
• 10006: je verstuurt te veel verzoeken. Pauzeer, lees de limietkopteksten en laat verzoeken daarna begrensd hervatten.
• Een time-out na place_order: verstuur niet direct opnieuw. Zoek eerst met het unieke orderLinkId of de order al bestaat.

Gebruik alleen automatische herhaling voor tijdelijke fouten waarbij de actie veilig opnieuw kan. Voeg een kleine willekeurige vertraging toe aan oplopende wachttijden, stel een maximum in en laat een softwareblokkade ingrijpen als fouten blijven terugkomen. Een parameterfout duizend keer per minuut herhalen is geen veerkracht, maar een defect.

De werkelijke kosten van handelen via een API

Een geautomatiseerd handelsprogramma kan transacties goedkoop laten lijken omdat je geen handmatig werk ziet. Toch moet een strategie minimaal rekening houden met handelskosten, bied-laatverschil, prijsafwijking bij uitvoering, financiering bij derivaten, infrastructuur en eventuele kosten van een externe dienst.

Een eenvoudig rekenvoorbeeld, los van de actuele tarieven van Bybit:

• Orderwaarde: €1.000
• Veronderstelde handelskosten: 0,10 procent bij koop en 0,10 procent bij verkoop
• Veronderstelde prijsafwijking bij uitvoering: 0,05 procent per kant

De koop en latere verkoop kosten dan in dit voorbeeld ongeveer 0,30 procent, oftewel €3, vóór infrastructuur en belasting. Een strategie met een verwacht voordeel van 0,20 procent is onder deze aannames verliesgevend, ook als ieder signaal technisch correct wordt uitgevoerd.

Gebruik voor een echte berekening je persoonlijke tarieven, je rol als liquiditeitsverschaffer of -nemer (maker of taker) en werkelijke uitvoeringsgegevens. Werk niet met een reclametarief dat niet bij jouw accountniveau of ordertype hoort.

Risicobeheer dat in de software hoort

Een stop-lossorder alleen is geen volwaardig risicosysteem. Goede API-software beperkt zowel marktrisico als technische schade.

Begin met harde grenzen aan de orderwaarde, de positie per munt, het aantal open orders en het verlies per dag. Zo kan een kommafout geen buitensporige order maken en blijft een stroom herhaalde signalen binnen een vooraf gekozen schadebereik. Zet deze grenzen in een aparte beveiligingslaag die de strategie niet kan aanpassen.

Controleer ook de kwaliteit van de invoer. Blokkeer een order als de prijsgegevens te oud zijn of de berekende prijs te sterk afwijkt van de recente markt. Vergelijk periodiek je eigen orderadministratie, posities en saldi met Bybit. Een verschil tussen beide administraties is reden om nieuwe orders te pauzeren en eerst te onderzoeken wat er ontbreekt.

Een noodstop blokkeert nieuwe orders bij een kritieke fout. Waarschuwingen zijn nodig wanneer verlies, foutpercentage, ouderdom van gegevens of positie buiten een ingestelde bandbreedte komt. Beide zijn nodig: een melding zonder blokkade kan te laat worden gezien, terwijl een blokkade zonder melding onverklaard stil kan blijven.

Een noodstop moet nieuwe orders blokkeren zonder de informatie te verwijderen die je nodig hebt om bestaande posities en orders veilig af te handelen. Test hem. Een knop die alleen in een draaiboek staat maar nooit onder belasting is geprobeerd, is geen betrouwbare controle.

Van proefopstelling naar gebruik met echt geld

Fase 1: alleen observeren

Bevestig eerst de entiteit, het accounttype en de toegestane API-route. Lees daarna alleen openbare marktgegevens en controleer tijdstempels, ontbrekende velden en herverbindingen. Bewaar geen persoonsgegevens of accountgegevens die je niet nodig hebt.

Fase 2: simuleren

Laat de strategie orders genereren zonder ze te verzenden. Gebruik echte instrumentregels en realistische kosten. Voer scenario’s uit met een leeg orderboek, vertraagde gegevens, dubbele berichten en time-outs. Dezelfde invoer moet tot reproduceerbare beslissingen leiden.

Fase 3: toegestane testomgeving

Gebruik de test- of demo-omgeving alleen als jouw account en entiteit die route ondersteunen. Test het plaatsen, gedeeltelijk vullen, annuleren en afwijzen van orders, plus het opnieuw verbinden na een storing. Dubbele gebeurtenissen mogen geen dubbele boekingen opleveren. Laat ook de noodstop en de afhandeling van snelheidslimieten aantoonbaar ingrijpen.

Fase 4: met een zeer klein bedrag in de productieomgeving

Start zonder hefboom en met één instrument. Gebruik een bedrag waarvan technisch verlies geen financieel probleem veroorzaakt. Vergelijk iedere order en uitvoering handmatig met de lokale administratie. Stel vooraf vast hoe lang de test stabiel moet lopen voordat je mag opschalen. Eén winstgevende dag is daarvoor geen bewijs.

Fase 5: beheerde productie

Scheid test- en productiegeheimen en leg versies, configuratiewijzigingen en ingebruiknames vast. Bewaak verlies, foutpercentages, verouderde gegevens, verbroken gegevensstromen en onverwachte posities. Plan toegangscontroles, periodieke vervanging van sleutels en herstelproeven. Houd een handmatig draaiboek bij voor een beursstoring of een afwijking in je eigen administratie.

Een Bybit API-sleutel verwijderen

Gebruik je een bestaande of oudere sleutel niet meer, verwijder hem dan. Volgens Bybits officiële algemene handleiding kan dat alleen via de website:

1. Log in, open het profielmenu en ga naar API Management.
2. Kies in de kolom voor bewerken de optie om de betreffende sleutel te verwijderen.
3. Bevestig de actie en rond de beveiligingsverificatie af.

Controleer daarna dat de toepassing geen toegang meer heeft en dat er geen onverwachte open orders overblijven. Een externe toepassing die via een toestemmingsscherm is gekoppeld, kan ook een eigen intrekactie hebben. Trek zowel de beurskoppeling als eventueel lokaal opgeslagen geheim materiaal in.

Verwijder of vervang een sleutel direct wanneer hij mogelijk is gelekt, wanneer een medewerker of leverancier geen toegang meer nodig heeft, wanneer het handelsprogramma niet meer wordt gebruikt of wanneer je onverklaarbare activiteit ziet. Wacht dan niet op de volgende geplande onderhoudsronde.

Veelgemaakte fouten bij traden met API

1. Algemene documentatie verwarren met EU-toegang. Een API-functie op de V5-site is geen accountrecht.
2. Een succesvolle REST-reactie als uitvoering boeken. Geaccepteerd is nog niet uitgevoerd.
3. Vaste decimalen gebruiken. Instrumentregels kunnen per handelspaar veranderen.
4. Na een time-out blind opnieuw sturen. Dat kan een dubbele order maken.
5. Alle rechten aanvinken. Meer rechten vergroten het schadebereik zonder de strategie beter te maken.
6. Opnamerechten geven. Een handelsproces heeft die normaal gesproken niet nodig.
7. Alleen normale scenario’s testen. Echte systemen falen ook op uitval, vertraging, gedeeltelijke uitvoeringen en dubbele berichten.
8. Geen kostenmodel bijhouden. Een bruto voordeel kan na handelskosten en prijsafwijking bij uitvoering verdwijnen.
9. Geen eigen orderadministratie bewaren. Zonder order- en uitvoeringsregister kun je de administratie niet betrouwbaar vergelijken.
10. Onbeperkt opschalen. Een technische fout hoort door harde maxima begrensd te blijven.

Veelgestelde vragen over traden met de Bybit API

Kan ik in Nederland zelf een Bybit API-sleutel aanmaken?

Ga daar niet zonder controle van uit. De officiële V5-foutcodetabel geeft 81007 bij een niet-ondersteunde aanmaakroute voor Bybit Europe. De integratiegids noemt voor de EU-site ondersteunde externe toepassingen voor API-brokergebruikers. Kijk daarom in je eigen Bybit EU-account welke sleutel- of partnerroute werkelijk beschikbaar is.

Kan ik automatisch traden op Bybit EU?

Dat kan alleen via functies en externe koppelingen die Bybit EU voor jouw account, land en product ondersteunt. Ga er niet vanuit dat een algemene V5-handleiding of codevoorbeeld automatisch op Bybit EU werkt.

Wat is het verschil tussen REST en WebSocket?

REST gebruik je voor een gericht verzoek, zoals instrumentgegevens ophalen of een order plaatsen. WebSocket houdt een verbinding open en stuurt meldingen over prijzen, orders of uitvoeringen zodra er iets verandert.

Is de testomgeving van Bybit beschikbaar voor Bybit EU?

De algemene Bybit-documentatie beschrijft een test- en demo-omgeving, maar dat is geen garantie voor een regulier Bybit EU-account. Controleer de toegestane accountroute. Gebruik een testomgeving niet om regionale beperkingen te omzeilen.

Is traden met API veilig?

Het kan beheersbaar worden ingericht, maar is nooit zonder risico. Beperk rechten en bedragen, gebruik geen opnamerechten, bescherm geheimen, controleer orderuitvoering en bouw limieten, waarschuwingen en een noodstop in.

Heeft een handelsbot opnamerechten nodig?

Normaal gesproken niet. Een handelsprogramma dat marktgegevens leest en orders uitvoert, hoeft geen crypto of geld van je account te kunnen opnemen. Vraagt een toepassing dit toch, stop dan en onderzoek waarom.

Waarom is mijn geaccepteerde order nog niet gevuld?

Een geaccepteerd API-verzoek betekent alleen dat Bybit het verzoek heeft ontvangen. De orderverwerking is asynchroon. Een limietorder kan wachten, gedeeltelijk worden uitgevoerd of onuitgevoerd blijven. Bevestig de toestand via de order- en uitvoeringsstromen.

Wat betekent Bybit-foutcode 10006?

Je hebt een API-snelheidslimiet geraakt. Lees de limietkopteksten, vertraag tot de toegestane hersteltijd en voorkom dat alle processen tegelijk opnieuw proberen. Blijf niet op volle snelheid verzoeken sturen.

Kan ik de Bybit API met Python gebruiken?

Voor accounts met geldige V5-toegang wel. Bybit onderhoudt daarvoor de Python-connector pybit. Gebruik geheimen via een veilige opslag, begin met alleen-lezen en test orders pas in een toegestane testomgeving.

Hoe verwijder ik een Bybit API-sleutel?

Ga op de Bybit EU-website via je profiel naar API Management, kies verwijderen bij de betreffende sleutel en rond de beveiligingscontrole af. Deze handeling is volgens Bybit alleen via de website beschikbaar.

Wat is beter: zelf code schrijven of een handelsbot gebruiken?

Zelf bouwen geeft meer controle, maar ook verantwoordelijkheid voor beveiliging, onderhoud en foutafhandeling. Een extern handelsprogramma bespaart ontwikkelwerk, maar voegt leveranciers- en toegangsrisico toe. De beste keuze hangt af van je technische kennis, controlebehoefte en risicobudget.

Levert handelen via een API automatisch winst op?

Nee. Een API voert regels uit. Rendement hangt af van de strategie, markt, kosten en uitvoering. Automatisering kan een verliesgevende regel net zo consequent uitvoeren als een winstgevende.