TurbineClient

from turbine_client import TurbineClient

client = TurbineClient(
    host="https://api.turbinefi.com",
    chain_id=137,
    private_key="0x...",  # Optional: for order signing
    api_key_id="your_key_id",  # Optional: for authenticated endpoints
    api_private_key="your_ed25519_key",  # Optional: for bearer token auth
    timeout=30.0
)

client.host  # Returns: str

client.chain_id  # Returns: int

client.address  # Returns: Optional[str]

client.can_sign  # Returns: bool

client.has_auth  # Returns: bool

with TurbineClient(host, chain_id, private_key) as client:
    markets = client.get_markets()
    # Client automatically closed on exit

client.get_health()

health = client.get_health()
print(health)  # {"status": "ok", "timestamp": 1234567890}

client.get_markets(chain_id=None)

markets = client.get_markets(chain_id=137)
for market in markets:
    print(f"{market.market_id}: {market.question}")

client.get_market(market_id)

stats = client.get_market("0x1234...")
print(f"Volume: ${stats.volume / 1e6:.2f}")
print(f"Yes price: {stats.yes_price / 1e6:.2%}")

client.get_orderbook(market_id, outcome=None)

book = client.get_orderbook(market_id)
if book.bids:
    best_bid = book.bids[0]
    print(f"Best bid: {best_bid.price / 1e6:.2%} for {best_bid.size / 1e6:.2f} shares")

client.get_trades(market_id, limit=100)

trades = client.get_trades(market_id, limit=50)
for trade in trades:
    print(f"Price: {trade.price / 1e6:.2%}, Size: {trade.size / 1e6:.2f}")

client.get_stats(market_id)

client.get_platform_stats()

stats = client.get_platform_stats()
print(f"Total volume: ${stats.total_volume / 1e6:.2f}")
print(f"Active markets: {stats.active_markets}")

client.get_holders(market_id, limit=100)

client.get_quick_market(asset)

market = client.get_quick_market("BTC")
strike_price = market.start_price / 1e6
print(f"BTC market strike: ${strike_price:,.2f}")

client.get_quick_market_history(asset, limit=100)

client.get_quick_market_price(asset)

price = client.get_quick_market_price("BTC")
print(f"BTC: ${price.price / 1e6:,.2f}")

client.get_quick_market_price_history(asset, limit=100)

client.get_resolution(market_id)

resolution = client.get_resolution(market_id)
if resolution.resolved:
    outcome = "YES" if resolution.winning_outcome == 0 else "NO"
    print(f"Market resolved: {outcome} won")

client.get_failed_trades()

client.get_pending_trades()

client.get_failed_claims()

client.get_pending_claims()

client.get_settlement_status(tx_hash)

client.create_order(order_args, settlement_address=None)

from turbine_client import OrderArgs, Side, Outcome
import time

order_args = OrderArgs(
    market_id="0x1234...",
    side=Side.BUY,
    outcome=Outcome.YES,
    price=600_000,  # 60%
    size=1_000_000,  # 1 share
    expiration=int(time.time()) + 3600
)
signed_order = client.create_order(order_args)

client.create_limit_buy(
    market_id,
    outcome,
    price,
    size,
    expiration=None,
    settlement_address=None
)

from turbine_client import Outcome

# Buy 10 YES shares at 55%
order = client.create_limit_buy(
    market_id="0x1234...",
    outcome=Outcome.YES,
    price=550_000,
    size=10_000_000
)

client.create_limit_sell(
    market_id,
    outcome,
    price,
    size,
    expiration=None,
    settlement_address=None
)

from turbine_client import Outcome

# Sell 5 NO shares at 40%
order = client.create_limit_sell(
    market_id="0x1234...",
    outcome=Outcome.NO,
    price=400_000,
    size=5_000_000
)

client.post_order(signed_order)

order = client.create_limit_buy(market_id, Outcome.YES, 500_000, 1_000_000)
response = client.post_order(order)
print(f"Order hash: {response['order_hash']}")

client.get_orders(trader=None, market_id=None, status=None)

open_orders = client.get_orders(status="open")
for order in open_orders:
    print(f"{order.order_hash}: {order.side} {order.size / 1e6:.2f} @ {order.price / 1e6:.2%}")

client.get_order(order_hash)

client.cancel_order(order_hash, market_id=None, side=None)

response = client.cancel_order("0xabcd...")
print(f"Cancelled: {response['success']}")

client.cancel_market_orders(market_id)

response = client.cancel_market_orders(market_id)
print(f"Cancelled {response['count']} orders")

client.get_positions(market_id, user_address=None)

client.get_user_positions(address, chain_id=None)

positions = client.get_user_positions(client.address)
for pos in positions:
    print(f"Market {pos.market_id}: {pos.yes_shares / 1e6:.2f} YES, {pos.no_shares / 1e6:.2f} NO")

client.get_user_orders(address, status=None)

client.get_user_activity(address)

client.get_user_stats()

stats = client.get_user_stats()
print(f"PnL: ${stats.pnl / 1e6:.2f}")
print(f"Position value: ${stats.position_value / 1e6:.2f}")

client.get_claimable_positions(address=None, verify=True)

result = client.get_claimable_positions()
print(f"Found {result['count']} claimable positions worth ${result['totalPayout']}")
for pos in result['claimable']:
    print(f"  {pos.market_id}: {pos.outcome} - ${pos.payout / 1e6:.2f}")

client.approve_usdc_for_settlement(settlement_address=None)

response = client.approve_usdc_for_settlement()
print(f"Approval tx: {response['tx_hash']}")

client.approve_ctf_for_settlement(settlement_address=None)

client.approve_usdc(amount, spender=None)

client.claim_winnings(market_contract_address)

response = client.claim_winnings("0x1234...")
print(f"Claim tx: {response['tx_hash']}")

client.batch_claim_winnings(market_contract_addresses)

markets = ["0x1234...", "0x5678...", "0xabcd..."]
response = client.batch_claim_winnings(markets)
print(f"Batch claim tx: {response['tx_hash']}")

client.claim_all_winnings()

response = client.claim_all_winnings()
print(f"Claimed all winnings: {response['tx_hash']}")

client.discover_positions(address=None)

result = client.discover_positions()
print(f"Claimable: ${result.total_claimable_usdc:.2f}")
print(f"Mergeable: ${result.total_mergeable_usdc:.2f}")

client.get_mergeable_positions(address=None)

client.get_usdc_balance(owner=None)

balance = client.get_usdc_balance()
print(f"USDC balance: ${balance / 1e6:.2f}")

client.get_usdc_allowance(owner=None, spender=None)

allowance = client.get_usdc_allowance()
if allowance > 0:
    print(f"USDC approved: ${allowance / 1e6:.2f}")
else:
    print("USDC not approved - call approve_usdc_for_settlement()")

client.sign_usdc_permit(value, settlement_address=None, deadline=None)

client.sync_permit_nonce(contract_address=None)

TurbineClient.request_api_credentials(host, private_key, name=None)

creds = TurbineClient.request_api_credentials(
    host="https://api.turbinefi.com",
    private_key="0x...",
    name="My Trading Bot"
)
print(f"API Key ID: {creds['api_key_id']}")
print(f"API Private Key: {creds['api_private_key']}")

from turbine_client.exceptions import AuthenticationError, TurbineApiError

try:
    order = client.create_limit_buy(market_id, Outcome.YES, 500_000, 1_000_000)
    response = client.post_order(order)
except AuthenticationError as e:
    print(f"Auth error: {e}")
except TurbineApiError as e:
    print(f"API error: {e}")

# Option 1: Context manager (recommended)
with TurbineClient(host, chain_id) as client:
    markets = client.get_markets()

# Option 2: Manual close
client = TurbineClient(host, chain_id)
try:
    markets = client.get_markets()
finally:
    client.close()