Examples & Recipes

Copy-paste recipes for common use cases. Each example is a complete, working script you can adapt to your needs.

Best For

Developers who already understand auth and want to move straight to a concrete workflow.

Use This Page When

You need a starting script for arbitrage, alerts, portfolio tracking, Kelly sizing, or history analysis.

Go Next

After a recipe works, tighten it with best practices, SDK configuration, and endpoint-specific docs.

Arbitrage Portfolio Discord Alerts Kelly Sizing Backtesting

Cross-Platform Arbitrage Scanner

Find risk-free profit opportunities across platforms

Scan for markets listed on multiple platforms where price discrepancies create arbitrage opportunities. Buy YES on one platform and NO on another for guaranteed profit.

Arbitrage scanner

import evsignals

client = evsignals.Client()

def find_arbitrage():
    """Find cross-platform arbitrage opportunities."""
    signals = client.signals.list(
        min_ev=0.01,
        status="active",
        limit=100
    )

    arb_opportunities = []
    for signal in signals.data:
        # Check if signal exists on multiple platforms
        market = client.markets.retrieve(signal.market_id)
        if market.cross_listed:
            odds_by_platform = {}
            for listing in market.listings:
                odds_by_platform[listing.platform] = {
                    "yes": listing.yes_price,
                    "no": listing.no_price,
                }

            # Check for arbitrage: yes on A + no on B < 1.0
            platforms = list(odds_by_platform.keys())
            for i, p1 in enumerate(platforms):
                for p2 in platforms[i+1:]:
                    cost = (odds_by_platform[p1]["yes"]
                            + odds_by_platform[p2]["no"])
                    if cost < 1.0:
                        arb_opportunities.append({
                            "market": market.name,
                            "buy_yes": p1,
                            "buy_no": p2,
                            "profit": 1.0 - cost,
                        })

    return arb_opportunities

opportunities = find_arbitrage()
for opp in opportunities:
    print(f"ARB: {opp['market']} - {opp['profit']:.2%} profit")

import EVSignals from 'evsignals';

const client = new EVSignals();

async function findArbitrage() {
  const signals = await client.signals.list({
    minEv: 0.01,
    status: 'active',
    limit: 100
  });

  const arbOpportunities = [];

  for (const signal of signals.data) {
    const market = await client.markets.retrieve(signal.marketId);
    if (!market.crossListed) continue;

    const oddsByPlatform = new Map();
    for (const listing of market.listings) {
      oddsByPlatform.set(listing.platform, {
        yes: listing.yesPrice,
        no: listing.noPrice,
      });
    }

    // Check for arbitrage: yes on A + no on B < 1.0
    const platforms = [...oddsByPlatform.keys()];
    for (let i = 0; i < platforms.length; i++) {
      for (let j = i + 1; j < platforms.length; j++) {
        const cost = oddsByPlatform.get(platforms[i]).yes
                   + oddsByPlatform.get(platforms[j]).no;
        if (cost < 1.0) {
          arbOpportunities.push({
            market: market.name,
            buyYes: platforms[i],
            buyNo: platforms[j],
            profit: 1.0 - cost,
          });
        }
      }
    }
  }

  return arbOpportunities;
}

const opps = await findArbitrage();
opps.forEach(opp =>
  console.log(`ARB: ${opp.market} - ${(opp.profit * 100).toFixed(2)}% profit`)
);

Portfolio Tracker

Monitor positions and P&L in real time

Build a portfolio dashboard that tracks your positions across markets, calculates unrealized P&L, and displays a summary sorted by performance.

Portfolio tracker

import evsignals

client = evsignals.Client()

def portfolio_summary(portfolio_id):
    """Get a comprehensive portfolio summary."""
    portfolio = client.portfolios.retrieve(portfolio_id)

    # Calculate metrics
    total_invested = sum(p.cost_basis for p in portfolio.positions)
    current_value = sum(p.current_value for p in portfolio.positions)
    pnl = current_value - total_invested

    print(f"Portfolio: {portfolio.name}")
    print(f"Positions: {len(portfolio.positions)}")
    print(f"Invested:  ${total_invested:,.2f}")
    print(f"Value:     ${current_value:,.2f}")
    print(f"P&L:       ${pnl:+,.2f} ({pnl/total_invested:+.2%})")

    # Show each position
    print("\nPositions:")
    for pos in sorted(
        portfolio.positions,
        key=lambda p: p.unrealized_pnl,
        reverse=True
    ):
        print(f"  {pos.market_name}")
        print(f"    Side: {pos.side} | Cost: ${pos.cost_basis:.2f}")
        print(f"    P&L:  ${pos.unrealized_pnl:+.2f}")

portfolio_summary("pf_abc123")

import EVSignals from 'evsignals';

const client = new EVSignals();

async function portfolioSummary(portfolioId) {
  const portfolio = await client.portfolios.retrieve(portfolioId);

  const totalInvested = portfolio.positions
    .reduce((sum, p) => sum + p.costBasis, 0);
  const currentValue = portfolio.positions
    .reduce((sum, p) => sum + p.currentValue, 0);
  const pnl = currentValue - totalInvested;

  console.log(`Portfolio: ${portfolio.name}`);
  console.log(`Positions: ${portfolio.positions.length}`);
  console.log(`Invested:  $${totalInvested.toFixed(2)}`);
  console.log(`Value:     $${currentValue.toFixed(2)}`);
  console.log(`P&L:       $${pnl.toFixed(2)}`);

  // Show each position sorted by P&L
  portfolio.positions
    .sort((a, b) => b.unrealizedPnl - a.unrealizedPnl)
    .forEach(pos => {
      console.log(`  ${pos.marketName}`);
      console.log(`    Side: ${pos.side} | Cost: $${pos.costBasis}`);
      console.log(`    P&L:  $${pos.unrealizedPnl.toFixed(2)}`);
    });
}

await portfolioSummary('pf_abc123');

Discord Alerts Bot

Send +EV alerts to your Discord channel

Use webhooks to receive real-time signal notifications and forward them as rich embeds to a Discord channel. Great for team alerts.

Discord alerts bot

import requests
from flask import Flask, request, jsonify
import hmac, hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "whsec_your_secret"
DISCORD_WEBHOOK = "https://discord.com/api/webhooks/..."

def send_discord_alert(signal):
    """Send a formatted alert to Discord."""
    embed = {
        "title": f"New +EV Signal: {signal['contract_name']}",
        "color": 0x10B981,  # Green
        "fields": [
            {"name": "EV", "value": f"{signal['ev_percent']}%", "inline": True},
            {"name": "Platform", "value": signal['market'], "inline": True},
            {"name": "Fair Value", "value": f"{signal['fair_value']}", "inline": True},
            {"name": "Price", "value": f"{signal['current_price']}", "inline": True},
        ],
    }
    requests.post(DISCORD_WEBHOOK, json={"embeds": [embed]})

@app.route('/webhooks/evsignals', methods=['POST'])
def handle_webhook():
    # Verify signature
    sig = request.headers.get('X-EVSignals-Signature')
    expected = hmac.new(
        WEBHOOK_SECRET.encode(), request.data, hashlib.sha256
    ).hexdigest()
    if not hmac.compare_digest(f"sha256={expected}", sig or ""):
        return jsonify({"error": "Invalid"}), 401

    event = request.get_json()
    if event["type"] == "signal.created":
        send_discord_alert(event["data"]["signal"])

    return jsonify({"ok": True}), 200

import express from 'express';
import crypto from 'crypto';

const app = express();
const WEBHOOK_SECRET = 'whsec_your_secret';
const DISCORD_WEBHOOK = 'https://discord.com/api/webhooks/...';

async function sendDiscordAlert(signal) {
  await fetch(DISCORD_WEBHOOK, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      embeds: [{
        title: `New +EV Signal: ${signal.contractName}`,
        color: 0x10B981,
        fields: [
          { name: 'EV', value: `${signal.evPercent}%`, inline: true },
          { name: 'Platform', value: signal.market, inline: true },
          { name: 'Fair Value', value: `${signal.fairValue}`, inline: true },
          { name: 'Price', value: `${signal.currentPrice}`, inline: true },
        ],
      }],
    }),
  });
}

app.post('/webhooks/evsignals',
  express.raw({ type: 'application/json' }),
  async (req, res) => {
    const sig = req.headers['x-evsignals-signature'];
    const expected = `sha256=${crypto
      .createHmac('sha256', WEBHOOK_SECRET)
      .update(req.body).digest('hex')}`;

    if (!crypto.timingSafeEqual(
      Buffer.from(sig || ''),
      Buffer.from(expected)
    )) return res.status(401).json({ error: 'Invalid' });

    const event = JSON.parse(req.body);
    if (event.type === 'signal.created') {
      await sendDiscordAlert(event.data.signal);
    }
    res.json({ ok: true });
  }
);

Adapt for Slack or Telegram: Replace the Discord webhook URL and payload format to send alerts to Slack (Incoming Webhooks) or Telegram (Bot API).

Kelly Criterion Position Sizing

Mathematically optimal bet sizing

Use the Kelly Criterion to calculate optimal position sizes based on your edge. We recommend using fractional Kelly (25%) to reduce variance while maintaining growth.

Kelly criterion sizing

import evsignals

client = evsignals.Client()

def kelly_fraction(probability, odds):
    """Calculate optimal Kelly bet size."""
    b = odds - 1  # Net odds (decimal odds - 1)
    q = 1 - probability
    return (b * probability - q) / b

def size_positions(bankroll, kelly_multiplier=0.25):
    """Size positions using fractional Kelly."""
    signals = client.signals.list(
        min_ev=0.02, status="active"
    )

    for signal in signals.data:
        fair_prob = signal.fair_value
        decimal_odds = 1 / signal.current_price

        full_kelly = kelly_fraction(fair_prob, decimal_odds)
        if full_kelly <= 0:
            continue  # Skip negative Kelly (no edge)

        # Use fractional Kelly for safety
        bet_fraction = full_kelly * kelly_multiplier
        bet_size = bankroll * bet_fraction

        print(f"{signal.contract_name}")
        print(f"  EV: {signal.ev_percent}% | Kelly: {full_kelly:.2%}")
        print(f"  Bet: ${bet_size:,.2f} ({bet_fraction:.2%} of bankroll)")

size_positions(bankroll=10000, kelly_multiplier=0.25)

import EVSignals from 'evsignals';

const client = new EVSignals();

function kellyFraction(probability, odds) {
  const b = odds - 1; // Net odds
  const q = 1 - probability;
  return (b * probability - q) / b;
}

async function sizePositions(bankroll, kellyMultiplier = 0.25) {
  const signals = await client.signals.list({
    minEv: 0.02, status: 'active'
  });

  for (const signal of signals.data) {
    const fairProb = signal.fairValue;
    const decimalOdds = 1 / signal.currentPrice;

    const fullKelly = kellyFraction(fairProb, decimalOdds);
    if (fullKelly <= 0) continue;

    const betFraction = fullKelly * kellyMultiplier;
    const betSize = bankroll * betFraction;

    console.log(signal.contractName);
    console.log(`  EV: ${signal.evPercent}% | Kelly: ${(fullKelly * 100).toFixed(2)}%`);
    console.log(`  Bet: $${betSize.toFixed(2)} (${(betFraction * 100).toFixed(2)}%)`);
  }
}

await sizePositions(10000, 0.25);

Risk Warning: Full Kelly can lead to extreme volatility. Most professionals use 1/4 Kelly or less. Never bet more than you can afford to lose.

Historical Backtest Analysis

Validate strategies before deploying capital

Run a full backtest against historical data, then drill into individual trades to understand strategy performance.

Backtest analysis

import evsignals

client = evsignals.Client()

# Backtest a simple +EV strategy
backtest = client.backtests.create(
    strategy={
        "min_ev": 0.03,
        "max_odds": 5.0,
        "position_sizing": "kelly",
        "kelly_fraction": 0.25,
    },
    start_date="2024-01-01",
    end_date="2025-12-31",
    initial_capital=10000,
    markets=["kalshi", "polymarket"]
)

# Get results
result = client.backtests.retrieve(backtest.id)

print("=== Backtest Results ===")
print(f"Period: {result.start_date} to {result.end_date}")
print(f"Total Return:  {result.total_return:.2%}")
print(f"Sharpe Ratio:  {result.sharpe_ratio:.2f}")
print(f"Max Drawdown:  {result.max_drawdown:.2%}")
print(f"Win Rate:      {result.win_rate:.2%}")
print(f"Total Trades:  {result.total_trades}")

# Analyze individual trades
trades = client.backtests.trades(backtest.id, limit=10)
print("\nTop 10 trades by P&L:")
for trade in sorted(trades.data, key=lambda t: t.pnl, reverse=True):
    print(f"  {trade.market_name}: ${trade.pnl:+,.2f}")

import EVSignals from 'evsignals';

const client = new EVSignals();

const backtest = await client.backtests.create({
  strategy: {
    minEv: 0.03,
    maxOdds: 5.0,
    positionSizing: 'kelly',
    kellyFraction: 0.25,
  },
  startDate: '2024-01-01',
  endDate: '2025-12-31',
  initialCapital: 10000,
  markets: ['kalshi', 'polymarket']
});

const result = await client.backtests.retrieve(backtest.id);

console.log('=== Backtest Results ===');
console.log(`Period: ${result.startDate} to ${result.endDate}`);
console.log(`Total Return:  ${(result.totalReturn * 100).toFixed(2)}%`);
console.log(`Sharpe Ratio:  ${result.sharpeRatio.toFixed(2)}`);
console.log(`Max Drawdown:  ${(result.maxDrawdown * 100).toFixed(2)}%`);
console.log(`Win Rate:      ${(result.winRate * 100).toFixed(2)}%`);
console.log(`Total Trades:  ${result.totalTrades}`);

const trades = await client.backtests.trades(backtest.id, { limit: 10 });
console.log('\nTop 10 trades by P&L:');
trades.data
  .sort((a, b) => b.pnl - a.pnl)
  .forEach(t => console.log(`  ${t.marketName}: $${t.pnl.toFixed(2)}`));

More Resources

Quickstart

Set up your first integration

Best Practices

Error handling, caching, security

SDKs

Python & Node.js libraries

EV Calculator

Calculate expected value online