Official SDKs

# Install with pip
pip install evsignals

# Or with poetry
poetry add evsignals

# Or with pipenv
pipenv install evsignals

// Install with npm
npm install evsignals

// Or with yarn
yarn add evsignals

// Or with pnpm
pnpm add evsignals

import evsignals

# Basic initialization
client = evsignals.Client(
    api_key="evs_live_your_api_key"
)

# With all configuration options
client = evsignals.Client(
    api_key="evs_live_your_api_key",
    base_url="https://api.evsignals.com",  # Custom endpoint
    timeout=30.0,                           # Request timeout (seconds)
    max_retries=3,                          # Auto-retry on failure
    api_version="2026-03-01"                # Pin to specific version
)

# Using environment variable (recommended)
# Set EVSIGNALS_API_KEY in your environment
client = evsignals.Client()  # Auto-loads from env

import EVSignals from 'evsignals';

// Basic initialization
const client = new EVSignals({
  apiKey: 'evs_live_your_api_key'
});

// With all configuration options
const client = new EVSignals({
  apiKey: 'evs_live_your_api_key',
  baseUrl: 'https://api.evsignals.com',  // Custom endpoint
  timeout: 30000,                          // Request timeout (ms)
  maxRetries: 3,                           // Auto-retry on failure
  apiVersion: '2026-03-01'                 // Pin to specific version
});

// Using environment variable (recommended)
// Set EVSIGNALS_API_KEY in your environment
const client = new EVSignals();  // Auto-loads from env

import asyncio
import evsignals

async def main():
    # Use async context manager
    async with evsignals.AsyncClient() as client:
        # Make concurrent requests
        signals, account = await asyncio.gather(
            client.signals.live(min_ev=2.0),
            client.account.get()
        )

        print(f"Found {len(signals)} signals")
        print(f"Account: {account.email}")

asyncio.run(main())

import EVSignals from 'evsignals';

async function main() {
  const client = new EVSignals();

  // Make concurrent requests
  const [signals, account] = await Promise.all([
    client.signals.live({ minEv: 2.0 }),
    client.account.get()
  ]);

  console.log(`Found ${signals.length} signals`);
  console.log(`Account: ${account.email}`);
}

main();

from evsignals import Client
from evsignals.types import Signal, Quote, Account

def process_signal(signal: Signal) -> None:
    """Process a single signal with full type safety."""
    print(f"Event: {signal.event}")
    print(f"EV: {signal.ev_percentage}%")
    print(f"Odds: {signal.best_odds}")

# IDE autocomplete works on all SDK objects
client = Client()
signals: list[Signal] = client.signals.live()

for signal in signals:
    process_signal(signal)

import EVSignals, {
  type Signal,
  type Quote,
  type Account
} from 'evsignals';

function processSignal(signal: Signal): void {
  // Full TypeScript support with autocomplete
  console.log(`Event: ${signal.event}`);
  console.log(`EV: ${signal.evPercentage}%`);
  console.log(`Odds: ${signal.bestOdds}`);
}

const client = new EVSignals();
const signals: Signal[] = await client.signals.live();

signals.forEach(processSignal);

from evsignals import Client
from evsignals.exceptions import (
    EVSignalsError,       # Base exception
    AuthenticationError,  # 401 errors
    RateLimitError,       # 429 errors
    NotFoundError,        # 404 errors
    ValidationError,      # 400 errors
    APIError              # All other API errors
)

client = Client()

try:
    signals = client.signals.live(min_ev=2.0)
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
except ValidationError as e:
    print(f"Invalid parameter: {e.param}")
except EVSignalsError as e:
    print(f"API error: {e.message}")

import EVSignals, {
  EVSignalsError,       // Base error class
  AuthenticationError,  // 401 errors
  RateLimitError,       // 429 errors
  NotFoundError,        // 404 errors
  ValidationError,      // 400 errors
  APIError              // All other API errors
} from 'evsignals';

const client = new EVSignals();

try {
  const signals = await client.signals.live({ minEv: 2.0 });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.log('Invalid API key');
  } else if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter}s`);
  } else if (error instanceof ValidationError) {
    console.log(`Invalid parameter: ${error.param}`);
  } else if (error instanceof EVSignalsError) {
    console.log(`API error: ${error.message}`);
  }
}