Creator Guide

🔒 Your bot runs in a sealed sandbox. It is never downloadable by buyers — they see results only, never your code. Access is restricted to our automated build-and-run system.

How it works

Your bot doesn't talk to an exchange directly and never holds API keys. Instead it submits orders to our SDK, and our broker executes them at the real price on the correct account — your account for your live track record, and each customer's account for their copy. That's what lets us give every bot a verified record (independently recorded by us) while keeping your code private.

What makes a bot rentable

The one rule for renting: your bot must place its orders through the CodeVaultEx SDK (vault.ccxt().create_order(...) or vault.place_order(...)) as its main order path — not by calling the exchange API directly with its own key.

Why: when a customer rents your bot, their copy runs without any API key inside it (we never put a renter's keys in your code — that's what keeps them safe). A bot that trades the exchange directly has nothing to authenticate with in a renter's copy, so it silently does nothing for them. A bot that goes through the SDK works everywhere: our broker executes each order on the right account with that person's key, which never touches your code.

If you don't: your bot still runs fine on your account and builds its verified track record — but it will show as “Not yet available to rent” in your dashboard and no one can subscribe to it until you route execution through the SDK. Kalshi, OANDA, Tradier and other “place the order yourself” bots especially need this change.

The only change you make

Keep all your strategy logic. Just route execution through vault:

import vault

ex = vault.ccxt()                 # drop-in ccxt-style client — no API keys needed
price = get_price("BTC/USDT")     # your own logic
if my_signal_is_buy:
    ex.create_order("BTC/USDT", "market", "buy", vault.size(price))   # sized to the runner's capital

Already using ccxt? Replace ccxt.binance({...keys...}) with vault.ccxt("binance") and delete your keys — your existing create_order(...) calls keep working. Always pass your venue to vault.ccxt(venue) (it defaults to coinbase) so orders route to the right exchange.

Prediction markets (Kalshi) & forex (OANDA)

The same SDK works for non-crypto venues — pass the venue and size in whole units. Pick the market in your own logic; the broker fills it on the correct account.

Kalshi — buy/sell whole contracts on a market ticker (price is dollars, 0.00–1.00, so int(vault.size(price)) sizes to capital automatically):

import vault
ex = vault.ccxt("kalshi")                    # route through the platform — no Kalshi key in your code
ticker = pick_market()                       # your logic → a Kalshi market ticker (this picks the YES side)
price  = get_yes_price(ticker)               # 0.00–1.00 (dollars per contract)
count  = int(vault.size(price))              # whole contracts, sized to the runner's capital
if my_signal_is_buy and count > 0:
    ex.create_order(ticker, "market", "buy",  count)   # enter the position
    # ... later, to close:
    ex.create_order(ticker, "market", "sell", count)   # exit

Betting the NO side? Append |no to the ticker — e.g. ex.create_order(ticker + "|no", "market", "buy", count) — and the broker places the correct leg and records your fill at the NO price. A plain ticker always means YES. Use the same ticker + "|no" when you sell to close that position.

Forex (OANDA) — signed units; use a dashed pair (the broker converts EUR-USD → EUR_USD). Your OANDA account id is the key you connect:

import vault
ex = vault.ccxt("oanda")
units = int(vault.size(rate))                # base-currency units, sized to capital (rate = the FX price)
if my_signal_is_buy and units > 0:
    ex.create_order("EUR-USD", "market", "buy",  units)   # long  (+units)
    ex.create_order("EUR-USD", "market", "sell", units)   # short / close (-units)

Replace your direct Kalshi/OANDA API calls with these — don't keep both. A bot that still calls the exchange directly with its own key can't trade for renters (their copy has no key), so it stays un-rentable. See What makes a bot rentable.

Paper mode works on every venue. In paper mode we fill your orders at live market prices from public data (Kalshi order books, stock & forex quotes) with an estimated-cost haircut — so you can run any bot risk-free and build a self-reported record before going live. Paper results are always labeled self-reported; only real execution is marked verified.

SDK reference

vault.capital() — the capital of whoever is running this copy (the customer, or you for live proof).
vault.size(price, risk_pct=2) — quantity sized to that capital (e.g. 2% per trade). Use this instead of a fixed amount so your bot scales to every customer automatically.
vault.ccxt(venue="coinbase") — a ccxt-compatible client whose create_order(symbol, "market", side, amount) routes safely through the broker.
vault.place_order(market, side, qty, venue) — lower-level order submit (returns the fill).
vault.record_trade(...) — optional self-reported trade (marked unverified; prefer real orders).

Supported venues: any major exchange (coinbase, binance, kraken, bybit, okx, kucoin, …). Pass the venue to vault.ccxt("binance").

🎯 Pick the venue your bot actually trades when you list it. Your listed exchange is authoritative — the broker routes every order to it and the buyer's connected key is locked to it, so a bot listed on Kraken always executes on Kraken even if a stray order is tagged otherwise. A buyer can only run your bot on the exchange you chose.

⚡ Auto-execution vs. signals-only by venue. Crypto exchanges (Coinbase, Kraken, Binance, OKX, … — 100+ via ccxt) support full hands-off auto-execution. Stocks, forex & prediction markets (Alpaca, OANDA, Tradier, Kalshi, Interactive Brokers) are verification & signals-only today: we read your real fills to verify the track record and the bot emits signals buyers place themselves — hands-off auto on those is rolling out.

Paper vs. live track record

When you list, you choose how your public record is built:

📝 Paper — runs at real market prices with estimated trading costs applied (a flat fee + a slippage haircut — not true order-book slippage), but no real money. Great to launch and prove the logic with zero risk.
💰 Live (real money) — you connect your own exchange account and the bot trades it for real. The record shows verified real fills. This is the most convincing proof to buyers — and the safest live case, since it's your money on your account.

Either way the record is verified by our broker and can't be faked. Live simply carries more weight.

Packaging your bot

A main.py at the top level (or a Dockerfile for any language).
Optional requirements.txt — we build your dependencies automatically.
≤ 45 MB, ≤ 500 files. Upload a .zip or connect a git repo (auto re-pulls on push). Tip: for bigger projects, a git repo has no size limit.

Starter template

import time, vault

MARKET, VENUE = "BTC-USD", "coinbase"
ex = vault.ccxt(VENUE)

def price():
    # your data/indicator logic here
    ...

while True:
    p = price()
    if buy_signal(p):
        ex.create_order(MARKET, "market", "buy",  vault.size(p, risk_pct=2))
    elif sell_signal(p):
        ex.create_order(MARKET, "market", "sell", vault.size(p, risk_pct=2))
    time.sleep(60)