Netherlands Stock API: Real-Time Quotes & Historical K-Line Data

      import websocket
import json
import threading
import time

# WebSocket endpoint and token
WS_URL = "wss://api.itick.org/stock"
API_TOKEN = "your_token_here"

def on_message(ws, message):
    """Handle incoming messages"""
    data = json.loads(message)

    # Handle successful connection
    if data.get("code") == 1 and data.get("msg") == "Connected Successfully":
        print("✅ WebSocket connected successfully, awaiting authentication...")

    # Handle authentication result
    elif data.get("resAc") == "auth":
        if data.get("code") == 1:
            print("✅ Authentication successful, starting subscription...")
            subscribe(ws)
        else:
            print("❌ Authentication failed")
            ws.close()

    # Handle subscription result
    elif data.get("resAc") == "subscribe":
        if data.get("code") == 1:
            print("✅ Subscription successful")
        else:
            print(f"❌ Subscription failed: {data.get('msg')}")

    # Handle market data
    elif data.get("data"):
        market_data = data["data"]
        data_type = market_data.get("type")
        symbol = market_data.get("s")

        if data_type == "quote":
            print(f"[{symbol}] Last: {market_data.get('ld')} EUR | "
                  f"Change %: {market_data.get('chp')}% | "
                  f"Volume: {market_data.get('v')}")
        elif data_type == "tick":
            print(f"[{symbol}] Trade: {market_data.get('ld')} EUR")
        elif data_type == "depth":
            bids = market_data.get("b", [])[:3]
            asks = market_data.get("a", [])[:3]
            print(f"[{symbol}] Bids: {bids} | Asks: {asks}")

def on_error(ws, error):
    print(f"❌ Error: {error}")

def on_close(ws, close_status_code, close_msg):
    print(f"🔌 Connection closed: {close_msg}, reconnecting in 5 seconds...")
    time.sleep(5)
    connect()

def on_open(ws):
    print("🌐 WebSocket connection opened")

def subscribe(ws):
    """Subscribe to Dutch equity real-time feeds"""
    subscribe_msg = {
        "ac": "subscribe",
        "params": "UNA$NL,ASML$NL,INGA$NL",  # Unilever, ASML, ING Group
        "types": "tick,quote,depth"
    }
    ws.send(json.dumps(subscribe_msg))
    print(f"📤 Subscription request sent")

def send_ping(ws):
    """Send heartbeat packets to maintain connection"""
    while True:
        time.sleep(30)
        if ws and ws.sock and ws.sock.connected:
            ping_msg = {
                "ac": "ping",
                "params": str(int(time.time() * 1000))
            }
            ws.send(json.dumps(ping_msg))
            print("💓 Heartbeat sent")

def connect():
    """Establish WebSocket connection"""
    global ws
    ws = websocket.WebSocketApp(
        WS_URL,
        header={"token": API_TOKEN},
        on_open=on_open,
        on_message=on_message,
        on_error=on_error,
        on_close=on_close
    )

    # Start heartbeat thread
    ping_thread = threading.Thread(target=send_ping, args=(ws,), daemon=True)
    ping_thread.start()

    # Run forever
    ws.run_forever()

if __name__ == "__main__":
    connect()

    

      import requests
import pandas as pd

API_TOKEN = "your_token_here"
BASE_URL = "https://api.itick.org"
HEADERS = {"token": API_TOKEN, "accept": "application/json"}

def get_kline(symbol, ktype=8, limit=100):
    """
    Retrieve historical K-line data for Dutch stocks
    :param symbol: Ticker, e.g. "ASML"
    :param ktype: Bar type, 8 = daily
    :param limit: Number of bars
    :return: List of K-line records
    """
    url = f"{BASE_URL}/stock/kline"
    params = {
        "region": "NL",
        "code": symbol,
        "kType": ktype,
        "limit": str(limit)
    }

    resp = requests.get(url, params=params, headers=HEADERS)
    data = resp.json()

    if data.get("code") == 0:
        klines = data.get("data", [])

        # Timeframe mapping
        ktype_map = {
            1: "1 min", 2: "5 min", 3: "15 min", 4: "30 min", 5: "60 min",
            8: "Daily", 9: "Weekly", 10: "Monthly"
        }

        print(f"✅ Retrieved {len(klines)} {ktype_map.get(ktype, '')} bars")

        # Print last 3 bars
        for item in klines[-3:]:
            print(f"Time:{item['t']} O:{item['o']} H:{item['h']} L:{item['l']} C:{item['c']} Vol:{item['v']}")

        return klines
    else:
        print(f"❌ Error: {data.get('msg')}")
        return []

# Example 1: ASML daily bars
print("📊 ASML Daily Data:")
asml_daily = get_kline("ASML", ktype=8, limit=30)

# Example 2: Unilever weekly bars
print("\n📊 Unilever Weekly Data:")
una_weekly = get_kline("UNA", ktype=9, limit=20)

# Example 3: ING Group 60-min bars
print("\n📊 ING Group 60-min Data:")
inga_hourly = get_kline("INGA", ktype=5, limit=50)

    

      def kline_to_dataframe(klines):
    """Convert K-line list to Pandas DataFrame"""
    if not klines:
        return None

    df = pd.DataFrame(klines)
    df['timestamp'] = pd.to_datetime(df['t'], unit='ms')
    df.set_index('timestamp', inplace=True)
    df.rename(columns={
        'o': 'open', 'h': 'high', 'l': 'low',
        'c': 'close', 'v': 'volume'
    }, inplace=True)

    # Convert to numeric
    for col in ['open', 'high', 'low', 'close', 'volume']:
        df[col] = pd.to_numeric(df[col])

    return df[['open', 'high', 'low', 'close', 'volume']]

# Example: Retrieve ASML data and convert
klines = get_kline("ASML", ktype=8, limit=100)
if klines:
    df = kline_to_dataframe(klines)
    print("\n📈 DataFrame head:")
    print(df.head())

    # Basic statistics
    print(f"\n📊 Statistics:")
    print(f"Latest close: {df['close'].iloc[-1]:.2f} EUR")
    print(f"Period high: {df['high'].max():.2f} EUR")
    print(f"Period low: {df['low'].min():.2f} EUR")