Your strategy. Every broker.
Zero real money.

curl -X POST https://simulator.dailytickers.com/api/accounts \
  -H "Authorization: Bearer bsim_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"broker":"alpaca","label":"My Strategy","account_type":"paper","initial_cash":100000}'

curl -X POST https://simulator.dailytickers.com/api/accounts/{id}/orders \
  -H "Authorization: Bearer bsim_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"symbol":"AAPL","side":"BUY","type":"MARKET","qty":10,"time_in_force":"DAY"}'

# 1. Create session
curl -X POST https://simulator.dailytickers.com/api/backtest \
  -H "Authorization: Bearer bsim_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"label":"AAPL momentum","start_time":"2024-01-01","end_time":"2024-12-31",
       "tick_size":"1d","symbols":["AAPL","MSFT"],"account_ids":["acct_xxx"]}'

# 2. Run to completion
curl -X POST https://simulator.dailytickers.com/api/backtest/{id}/run \
  -H "Authorization: Bearer bsim_YOUR_KEY"

# 3. Get equity curve + performance metrics
curl https://simulator.dailytickers.com/api/backtest/{id}/equity-curve \
  -H "Authorization: Bearer bsim_YOUR_KEY"

curl https://simulator.dailytickers.com/api/accounts/{id}/portfolio \
  -H "Authorization: Bearer bsim_YOUR_KEY"
# → { "cash": 89450.20, "positions": [...], "total_equity": 107820.50 }

# API_BASE = "https://simulator.dailytickers.com/api"

SESSION=$(curl -s -X POST https://simulator.dailytickers.com/api/backtest \
  -H "Authorization: Bearer $SIM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "label":      "aapl-momentum-2023",
    "start_time": "2023-01-01",
    "end_time":   "2023-12-31",
    "tick_size":  "1d",
    "symbols":    ["AAPL"]
  }')

SESSION_ID=$(echo "$SESSION" | jq -r '.id')

echo "WS URL: wss://simulator.dailytickers.com/api/backtest/$SESSION_ID/ws"

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/hbfs-cloud/broker-simulator/remotestrategy"
)

// WS_BASE = "wss://simulator.dailytickers.com/api"

type BuyAndHoldAAPL struct {
	bars   map[string][]remotestrategy.Bar
	bought bool
}

func (s *BuyAndHoldAAPL) Init(bars map[string][]remotestrategy.Bar) error {
	s.bars = bars
	return nil
}

func (s *BuyAndHoldAAPL) OnTick(tick remotestrategy.Tick) ([]remotestrategy.AccountActions, error) {
	var all []remotestrategy.AccountActions
	for _, acct := range tick.Accounts {
		actions := remotestrategy.AccountActions{AccountID: acct.AccountID}
		var pos *remotestrategy.Position
		for i := range acct.Positions {
			if acct.Positions[i].Symbol == "AAPL" {
				pos = &acct.Positions[i]
			}
		}
		if pos == nil && !s.bought {
			actions.Create = []remotestrategy.OrderRequest{{Symbol: "AAPL", Side: "BUY", Type: "MARKET", Qty: 10}}
			s.bought = true
		} else if pos != nil {
			gain := (pos.CurrentPrice - pos.AvgEntry) / pos.AvgEntry
			if gain > 0.20 {
				actions.Create = []remotestrategy.OrderRequest{{Symbol: "AAPL", Side: "SELL", Type: "MARKET", Qty: pos.Qty}}
				s.bought = false
			}
		}
		all = append(all, actions)
	}
	return all, nil
}

func main() {
	sessionID := os.Getenv("SESSION_ID")
	if sessionID == "" {
		log.Fatal("SESSION_ID env var required")
	}
	wsURL := fmt.Sprintf("wss://simulator.dailytickers.com/api/backtest/%s/ws", sessionID)
	client := remotestrategy.NewClient(&BuyAndHoldAAPL{})
	log.Fatal(client.Connect(context.Background(), wsURL))
}

"""Simple momentum strategy: buy AAPL if the 5-day return exceeds 2%.

Usage:
  export SESSION_ID=<your-backtest-session-id>
  export SIM_API_KEY=bsim_...
  pip install websockets
  python strategy.py
"""
# WS_BASE = "wss://simulator.dailytickers.com/api"
import asyncio, json, os
import websockets

SESSION_ID = os.environ["SESSION_ID"]
API_KEY    = os.environ.get("SIM_API_KEY", "")
WS_URL     = f"wss://simulator.dailytickers.com/api/backtest/{SESSION_ID}/ws"

MOMENTUM_THRESHOLD = 0.02
LOOKBACK_DAYS      = 5

async def run():
    headers = {"Authorization": f"Bearer {API_KEY}"} if API_KEY else {}
    async with websockets.connect(WS_URL, additional_headers=headers) as ws:
        # Receive full OHLCV history
        init = json.loads(await ws.recv())
        assert init["type"] == "init"
        bars: dict = init["bars"]
        await ws.send(json.dumps({"type": "init_ok"}))

        async for raw in ws:
            msg = json.loads(raw)
            if msg["type"] == "done":
                break
            if msg["type"] != "tick":
                continue

            account_actions = []
            for acct in msg["accounts"]:
                positions = {p["symbol"]: p for p in acct["positions"]}
                orders = []
                aapl_bars = bars.get("AAPL", [])
                if len(aapl_bars) >= LOOKBACK_DAYS + 1:
                    ret_5d = (aapl_bars[-1]["c"] - aapl_bars[-(LOOKBACK_DAYS+1)]["c"]) / aapl_bars[-(LOOKBACK_DAYS+1)]["c"]
                    if ret_5d > MOMENTUM_THRESHOLD and "AAPL" not in positions:
                        orders.append({"symbol": "AAPL", "side": "BUY", "type": "MARKET", "qty": 10})
                    elif ret_5d <= 0 and "AAPL" in positions:
                        orders.append({"symbol": "AAPL", "side": "SELL", "type": "MARKET", "qty": positions["AAPL"]["qty"]})
                account_actions.append({"account_id": acct["account_id"], "create": orders})

            await ws.send(json.dumps({"type": "actions", "accounts": account_actions}))

asyncio.run(run())

// LLM trading agent: streams tick JSON to Claude, executes its order decisions.
// npm install ws @anthropic-ai/sdk
// export SIM_API_KEY=bsim_...  ANTHROPIC_API_KEY=sk-ant-...  SESSION_ID=...

// WS_BASE = "wss://simulator.dailytickers.com/api"
import Anthropic from "@anthropic-ai/sdk";
import WebSocket  from "ws";

const { SIM_API_KEY, ANTHROPIC_API_KEY, SESSION_ID } = process.env;
const WS_URL = `wss://simulator.dailytickers.com/api/backtest/${SESSION_ID}/ws`;

const anthropic = new Anthropic({ apiKey: ANTHROPIC_API_KEY });
const ws = new WebSocket(WS_URL, { headers: { Authorization: `Bearer ${SIM_API_KEY}` } });

let bars = {};

async function askClaude(tick, recentBars) {
  const msg = await anthropic.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 256,
    messages: [{
      role: "user",
      content: `You are a quant trader. Given the tick and recent bars, decide orders.
Return a JSON array: [{account_id, symbol, side, type, qty}] or [].

Tick: ${JSON.stringify(tick)}
Recent bars: ${JSON.stringify(recentBars.slice(-10))}`,
    }],
  });
  try { return JSON.parse(msg.content[0].text.trim()); }
  catch { return []; }
}

ws.on("message", async (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.type === "init") { bars = msg.bars; ws.send(JSON.stringify({ type: "init_ok" })); return; }
  if (msg.type === "done") { ws.close(); return; }
  if (msg.type !== "tick") return;

  const orders = await askClaude(msg, bars["AAPL"] ?? []);
  const byAccount = {};
  for (const o of orders) {
    if (!byAccount[o.account_id]) byAccount[o.account_id] = { account_id: o.account_id, create: [] };
    const { account_id, ...req } = o;
    byAccount[o.account_id].create.push(req);
  }
  ws.send(JSON.stringify({ type: "actions", accounts: Object.values(byAccount) }));
});