Alpaca-py: Hoe gebruik je de officiële Alpaca Trade API SDK?

Alex de Vries

Quantitatief Analist & Algo-Trading Expert

Python Libraries voor Algoritmische Trading · 2026-02-15 · 7 min leestijd

Stel je voor: je hebt een killer-strategie bedacht voor de aandelenmarkt. Iets wat misschien wel de volgende grote trading bot wordt.

Je wilt 'm testen, live laten draaien, maar je wilt niet meteen duizenden euro's van je zuurverdiende spaargeld op het spel zetten. Het klinkt als een droom, maar met de juiste tools is het binnen handbereik. De sleutel?

De Alpaca API, en specifiker nog: de alpaca-py SDK. Dit is de officiële, moderne manier om met de Alpaca broker te praten vanuit Python. Het is de brug tussen jouw slimme code en de echte markt. In deze handleiding neem ik je bij de hand en bouwen we samen een simpele, maar krachtige, trading script. Geen poespas, gewoon code die werkt.

Wat je nodig hebt voordat we beginnen

Voordat we een enkele regel code typen, moeten we onze gereedschapskist vullen.

Denk hieraan als het opzetten van je werkplaats voordat je gaat sleutelen. Je hebt niet veel nodig, maar wat je nodig hebt, is essentieel. Als je hierop bespaart, loop je straks tegen vervelende muurtjes aan.

Allereerst heb je Python nodig. Zorg dat je versie 3.8 of hoger geïnstalleerd hebt.

Check dit even door in je terminal python --version te typen. Als je een oudere versie hebt, update 'm.

De wereld van trading bots beweegt snel, en oude software zorgt voor beveiligingsrisico's en bugs die je niet wilt. Je hebt een code-editor nodig. VS Code is een topkeuze, gratis en super populair. Ook handig: een terminal of command prompt.

Daar gaan we de installaties doen. Tot slot, en dit is cruciaal, heb je een Alpaca account nodig.

Ga naar de Alpaca website, meld je aan voor een Paper Trading account. Dit is een gesimuleerde omgeving met nepgeld. Zo kun je risicoloos oefenen.

Je vindt je API key en secret key in je Alpaca dashboard.

Kopieer deze en bewaar ze veilig. Ze zijn je wachtwoord naar de markten.

Stap 1: Je omgeving opzetten en alpaca-py installeren

Je wilt je project netjes houden. Je wilt niet dat je trading bot straks ruzie maakt met een ander Python-project.

Daarom beginnen we met een virtuele omgeving. Dit is een soort afgesloten bubbel voor je project.

python -m venv trading_env (Dit maakt de virtuele omgeving aan. Je mag 'm een andere naam geven, maar hou het simpel).
source trading_env/bin/activate (Op Mac/Linux) of trading_env\Scripts\activate (Op Windows). Je ziet nu een (trading_env) voor je prompt staan. Je zit in de bubbel!
pip install alpaca-py (Dit haalt de Alpaca SDK binnen).
pip install pandas (We hebben deze nodig voor data-analyse).

Zo voorkomt je dat library-versies met elkaar conflicteren. Open je terminal en navigeer naar een map waar je je project wilt starten. Typ de volgende commando's:

Veelgemaakte fout: Vergeet niet de virtuele omgeving te activeren. Als je pip install typt zonder dat je (trading_env) ziet, installeer je de libraries op je hoofdsysteem. Dat wil je niet. Tijdsindicatie: Dit duurt ongeveer 3-5 minuten, inclusief het downloaden van de packages.

Stap 2: Je API-sleutels beveiligen (nooit hardcoden!)

Hier gaat een beginnersfout vaak mis. Je typt je API-sleutels letterlijk in je Python-script. Doe dit nooit. Als je je code per ongeluk naar GitHub pusht, hebben hackers direct toegang tot je (nep)geld.

We lossen dit op met omgevingsvariabelen. Het is een extra stap, maar het is de gouden standaard voor beveiliging. De makkelijkste manier is om een .env bestand te maken in je projectmap.

Maak een nieuw bestand aan, noem het .env (let op de punt ervoor!).

APCA_API_KEY_ID=je_papieren_api_key
APCA_API_SECRET_KEY=je_papieren_secret_key

Vul het zo in: Vervang de tekens met je echte keys uit je Alpaca dashboard. Om dit bestand te kunnen gebruiken, heb je de Alpaca-py library voor commissievrij traden nodig die het inleest.

Stop dit even in je terminal: pip install python-dotenv. Nu ben je klaar om je keys veilig in te laden in je script. Je script kan nu veilig je identiteit bewijzen bij Alpaca, zonder dat je gevoelige data blootstelt.

Stap 3: Verbinding maken en je eerste data ophalen

Tijd voor de eerste echte code. We gaan niet direct traden, we gaan eerst kijken wat de markt doet.

Dit is de basis van elke trading bot: data. Zonder data is traden gokken. We gaan de koersgegevens van een bekend aandeel, bijvoorbeeld Apple (AAPL), ophalen.

Maak een nieuw Python-bestand aan, bijvoorbeeld eerste_stap.py. Hieronder vindt je de code.

from alpaca.trading.client import TradingClient
from alpaca.data.historical import StockHistoricalDataClient
from alpaca.data.requests import StockBarsRequest
from alpaca.data.timeframe import TimeFrame
from dotenv import load_dotenv
import os

# Laad je .env bestand
load_dotenv()

# Haal je keys op uit de omgeving
API_KEY = os.getenv("APCA_API_KEY_ID")
SECRET_KEY = os.getenv("APCA_API_SECRET_KEY")

# Maak verbinding met de data client (niet de trading client, we willen alleen data)
data_client = StockHistoricalDataClient(API_KEY, SECRET_KEY)

# Stel de request in: welk aandeel, welke timeframe, hoe ver terug?
request_params = StockBarsRequest(
    symbol_or_symbols=["AAPL"],
    timeframe=TimeFrame.Day,
    start="2023-01-01",
    end="2023-12-31"
)

# Haal de data op
bars = data_client.get_stock_bars(request_params)

# Print de eerste 5 rijen
print(bars.df.head())

Kopieer 'm en leg ik je uit wat er gebeurt. Wat gebeurt hier? We laden onze keys, maken een data-client aan, en vragen om de dagelijkse koersen van AAPL voor het hele jaar 2023. De output die je ziet is een DataFrame van Pandas, een tabel met open, high, low, close en volume.

Dit is de grondstof voor je analyse. Veelgemaakte fout: Een typefout in je API-key. Controleer dubbel. Tijdsindicatie: Ongeveer 10 minuten om dit te begrijpen en te debuggen.

Stap 4: Een order plaatsen met de Trading Client

Oké, data ophalen is leuk, maar het echte werk is natuurlijk een order plaatsen.

We gaan nu een nep-order sturen via je Paper Trading account. Je riskeert nog steeds niets, maar het voelt wel echt.

We kopen 10 aandelen AAPL. Voeg deze code toe aan je bestand of maak een nieuw bestand. We gebruiken nu de TradingClient. Run deze code.

# Voeg deze imports bovenaan je bestand toe
from alpaca.trading.requests import MarketOrderRequest
from alpaca.trading.enums import OrderSide, TimeInForce

# Maak de trading client aan
trading_client = TradingClient(API_KEY, SECRET_KEY, paper=True) # paper=True is essentieel voor nepgeld!

# Stel de order in
market_order_data = MarketOrderRequest(
    symbol="AAPL",
    qty=10,
    side=OrderSide.BUY,
    time_in_force=TimeInForce.DAY
)

# Plaats de order
try:
    order = trading_client.submit_order(order_data=market_order_data)
    print("Order geplaatst!")
    print(f"Order ID: {order.id}")
    print(f"Status: {order.status}")
except Exception as e:
    print(f"Er is iets misgegaan: {e}")

Als het goed is, zie je "Order geplaatst!" met een unieke ID.

Dit is het moment dat je bot 'wakker' wordt. Je vertelt de broker: "Koop nu 10 aandelen Apple voor de beste beschikbare prijs". Veelgemaakte fout: Vergeten om paper=True te zetten. Als je dat vergeet, probeer je misschien met echt geld te handelen! Altijd dubbelcheck dit. Tijdsindicatie: 5 minuten om te testen.

Stap 5: Je portfolio checken en de order sluiten

Een trade plaatsen is stap 1, maar je moet ook weten wat je positie is. En misschien wil je je positie wel sluiten.

We checken onze portfolio en verkopen de net gekochte aandelen weer. Deze code laat je zien hoe je je posities opvraagt en een verkooporder plaatst.

# Haal je huidige posities op
positions = trading_client.get_all_positions()
print("Huidige posities:")
for position in positions:
    print(f"Aandeel: {position.symbol}, Aantal: {position.qty}")

# Als we posities hebben, verkopen we ze
if positions:
    for position in positions:
        qty = int(position.qty)
        symbol = position.symbol
        
        # Maak een verkooporder aan
        close_order = MarketOrderRequest(
            symbol=symbol,
            qty=qty,
            side=OrderSide.SELL,
            time_in_force=TimeInForce.DAY
        )
        
        # Plaats de verkooporder
        trading_client.submit_order(order_data=close_order)
        print(f"Verkooporder geplaatst voor {qty} aandelen {symbol}")
else:
    print("Je hebt geen open posities.")

Dit is essentieel voor risicomanagement. Je moet weten wat je open posities zijn voordat je nieuwe trades plaatst. Deze logica is de basis voor elk sluitsysteem.

Als je bot ziet dat een trade niet werkt, of een doel heeft bereikt, moet hij deze code kunnen draaien om de positie te sluiten en winst (of verlies) te realiseren. Veelgemaakte fout: Proberen meer te verkopen dan je hebt. De API geeft een fout. Check dus altijd je 'qty'.

Verificatie-checklist

Als je bovenstaande stappen hebt doorlopen, heb je een werkende basis. Je kunt data ophalen, orders plaatsen en je portfolio beheren. Dat is 80% van de technische kant van algo-trading.

Loop deze checklist na om te zien of je alles goed hebt gedaan:

Virtuele omgeving: Is je trading_env actief en heb je alpaca-py en pandas geïnstalleerd?
Veiligheid: Gebruik je een .env bestand en python-dotenv? Zit je API-key erin?
Data: Kreeg je een DataFrame te zien met AAPL koersen uit 2023?
Paper Trading: Heb je bij het aanmaken van de TradingClient paper=True gebruikt?
Orders: Zie je in je Alpaca dashboard (onder 'Orders') dat je order is geplaatst en uitgevoerd?
Posities: Zag je na het kopen een positie staan? En na het verkopen was deze weer weg?

Als je overal 'ja' op kunt antwoorden, gefeliciteerd! Je hebt zojuist je eerste functionerende trading bot in Python gebouwd, klaar om uit te breiden met 80+ technische indicatoren via FinTA.

De volgende stap is dit script uitbreiden met logica: een indicator toevoegen, een stop-loss instellen, of meerdere aandelen tegelijkertijd monitoren. Wil je jouw trading algoritme veilig containerizen? De wereld van algoritmische trading ligt aan je voeten. Veel succes met bouwen!