npm install altsportsdata

yarn add altsportsdata

import { AltSportsData } from 'altsportsdata';

const client = new AltSportsData({
  apiKey: process.env.ALTSPORTSDATA_API_KEY
});

// Fetch elite soccer leagues
const leagues = await client.leagues.list({
  sportType: 'Soccer',
  tier: 'elite'
});

console.log(leagues.data);

const client = new AltSportsData({
  apiKey: 'your-api-key'
});

const client = new AltSportsData({
  apiKey: 'your-api-key',
  baseUrl: 'https://api.altsportsdata.com/v1', // Custom base URL
  timeout: 30000, // Request timeout in ms (default: 30000)
  retry: {
    enabled: true, // Enable auto-retry (default: true)
    maxRetries: 3, // Max retry attempts (default: 3)
    initialDelay: 1000, // Initial retry delay in ms
    maxDelay: 10000 // Max retry delay in ms
  },
  headers: {
    'X-Custom-Header': 'value' // Additional headers
  }
});

// List leagues
const leagues = await client.leagues.list({
  sportType: 'Soccer',
  tier: 'elite',
  country: 'GB',
  limit: 50,
  offset: 0
});

// Get specific league
const league = await client.leagues.get('league_001');

// Get league statistics
const stats = await client.leagues.stats();

// Get league fingerprint
const fingerprint = await client.leagues.fingerprint('league_001');

// Get league valuation
const valuation = await client.leagues.valuation('league_001');

// Get qualification score
const qualification = await client.leagues.qualification('league_001');

// Get readiness report
const readiness = await client.leagues.readiness('league_001');

// Compare leagues
const comparison = await client.leagues.compare('league_001', 'league_002');

// Find similar leagues
const similar = await client.leagues.similar('league_001', { limit: 10 });

// Re-evaluate league
await client.leagues.evaluate('league_001');

// Search leagues
const results = await client.discovery.search({
  q: 'premier league',
  limit: 10
});

// Find similar leagues (vector search)
const similar = await client.discovery.similar('league_001', {
  limit: 10
});

// Evaluate league
const evaluation = await client.valuation.evaluate({
  leagueId: 'league_001'
});

// Get tier definitions
const tiers = await client.valuation.tiers();

// List all sports
const sports = await client.sports.list();

// Get sport archetypes
const archetypes = await client.sports.archetypes();

// List events
const events = await client.events.list({
  leagueId: 'league_001',
  dateFrom: '2026-03-01',
  dateTo: '2026-03-31',
  limit: 100
});

// List betting markets
const markets = await client.markets.list({
  limit: 50
});

import type {
  League,
  LeagueReadiness,
  LeagueValuation,
  Sport,
  Event,
  Market,
  ListLeaguesRequest,
  ListLeaguesResponse
} from 'altsportsdata';

// Type-safe requests
const params: ListLeaguesRequest = {
  sportType: 'Soccer',
  tier: 'elite'
};

const response: ListLeaguesResponse = await client.leagues.list(params);

// Type-safe response handling
const league: League = response.data[0];
console.log(league.name); // Autocomplete available

import {
  AltSportsDataError,
  ResourceNotFoundError,
  RateLimitError,
  ValidationError,
  AuthenticationError
} from 'altsportsdata';

try {
  const league = await client.leagues.get('invalid_id');
} catch (error) {
  if (error instanceof ResourceNotFoundError) {
    console.error('League not found:', error.message);
  } else if (error instanceof RateLimitError) {
    console.error('Rate limit exceeded');
    console.log(`Retry after: ${error.retryAfter} seconds`);
  } else if (error instanceof ValidationError) {
    console.error('Validation failed:', error.details);
  } else if (error instanceof AuthenticationError) {
    console.error('Invalid API key');
  } else if (error instanceof AltSportsDataError) {
    console.error('API error:', error.message);
  }
}

let offset = 0;
const limit = 100;
const allLeagues: League[] = [];

while (true) {
  const response = await client.leagues.list({ limit, offset });
  allLeagues.push(...response.data);

  if (!response.meta.has_more) break;
  offset += limit;
}

// Async iterator (automatically handles pagination)
const allLeagues: League[] = [];

for await (const league of client.leagues.listAll({ tier: 'elite' })) {
  allLeagues.push(league);
}

// Access rate limit info from response
const response = await client.leagues.list();

console.log('Rate Limit Info:');
console.log(`  Limit: ${response.rateLimit.limit}`);
console.log(`  Remaining: ${response.rateLimit.remaining}`);
console.log(`  Reset: ${new Date(response.rateLimit.reset * 1000)}`);

// Auto-retry on rate limit (with exponential backoff)
const client = new AltSportsData({
  apiKey: 'your-api-key',
  retry: {
    enabled: true,
    maxRetries: 5,
    respectRateLimits: true // Wait for rate limit reset
  }
});

// Global timeout
const client = new AltSportsData({
  apiKey: 'your-api-key',
  timeout: 60000 // 60 seconds
});

// Per-request timeout
const league = await client.leagues.get('league_001', {
  timeout: 10000 // Override for this request
});

# .env file
ALTSPORTSDATA_API_KEY=your-api-key
ALTSPORTSDATA_BASE_URL=https://api.altsportsdata.com/v1

import { config } from 'dotenv';
config();

const client = new AltSportsData({
  apiKey: process.env.ALTSPORTSDATA_API_KEY,
  baseUrl: process.env.ALTSPORTSDATA_BASE_URL
});