AltSportsLeagues.ai API Reference

# Get your API key
curl -X POST https://api.altsportsleagues.ai/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"your-email@domain.com","password":"your-password"}'
 
# Make your first API call
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.altsportsleagues.ai/api/v1/leagues

const headers = {
  'Authorization': `Bearer ${apiKey}`,
  'Content-Type': 'application/json',
  'X-API-Version': 'v1'
};

{
  "email": "user@altsportsleagues.ai",
  "password": "secure-password"
}

{
  "access_token": "eyJhbGciOiJIUzI1NiIs...",
  "token_type": "bearer",
  "expires_in": 3600,
  "user": {
    "id": "user_123",
    "email": "user@altsportsleagues.ai",
    "role": "league_admin"
  }
}

Authorization: Bearer <your-jwt-token>

X-API-Key: <your-api-key>

Authorization: Bearer <oauth-access-token>

{
  "pdf_path": "gs://bucket/questionnaires/league_questionnaire_cpl.pdf",
  "league_name": "Canadian Premier League",
  "config": {
    "jira_project": "ASD",
    "google_drive_parent": "League Partnerships 2025",
    "contract_flavors": ["conservative", "balanced", "aggressive", "premium"],
    "research_config": {
      "budget_usd": 5.0,
      "timeout_seconds": 300,
      "min_quality": 0.75
    }
  }
}

{
  "status": "success",
  "pipeline_id": "pip_abc123",
  "results": {
    "fingerprint_id": "fpr_xyz789",
    "partnership_score": 0.67,
    "recommended_tier": "Silver",
    "google_drive_folder": "https://drive.google.com/drive/folders/...",
    "jira_card": {
      "key": "ASD-1234",
      "url": "https://altsportsdata.atlassian.net/browse/ASD-1234"
    },
    "processing_time_seconds": 442,
    "total_cost_usd": 2.35
  },
  "documents": {
    "fingerprint_json": "https://drive.google.com/file/d/...",
    "contract_doc": "https://docs.google.com/document/d/...",
    "contract_flavors_json": "https://drive.google.com/file/d/...",
    "scorecard_sheet": "https://docs.google.com/spreadsheets/d/..."
  }
}

{
  "pdf_paths": [
    "gs://bucket/questionnaires/*.pdf"
  ],
  "config": {
    "max_concurrent": 5,
    "jira_project": "ASD",
    "google_drive_parent": "League Partnerships 2025"
  }
}

{
  "status": "completed",
  "batch_id": "bat_def456",
  "summary": {
    "total": 9,
    "successful": 9,
    "failed": 0,
    "total_time_seconds": 1296,
    "total_cost_usd": 21.15,
    "average_quality": 0.79
  },
  "results": [
    {
      "league_name": "Canadian Premier League",
      "fingerprint_id": "fpr_xyz789",
      "jira_card": "ASD-1234",
      "status": "success"
    }
  ],
  "report_url": "gs://bucket/reports/batch_20250115.json"
}

{
  "pipeline_id": "pip_abc123",
  "status": "running",
  "stage": "research",
  "progress": 0.62,
  "stages": {
    "extraction": { "status": "completed", "duration_seconds": 2.3 },
    "research": { "status": "running", "elapsed_seconds": 98.7 },
    "scoring": { "status": "pending" },
    "contracts": { "status": "pending" },
    "google_drive": { "status": "pending" },
    "jira": { "status": "pending" }
  },
  "estimated_completion_seconds": 203
}

interface PartnershipScoring {
  // Market opportunity and reach (25% weight)
  market_size: number;
 
  // Data completeness and quality (20% weight)
  data_quality: number;
 
  // Technical integration readiness (20% weight)
  integration_readiness: number;
 
  // Betting market potential (20% weight)
  betting_potential: number;
 
  // Strategic alignment (15% weight)
  strategic_fit: number;
 
  // Final calculations
  overall_score: number;      // 0.00-1.00
  tier: 'Bronze' | 'Silver' | 'Gold' | 'Platinum';
  confidence_level: number;   // 0.00-1.00
}

interface LeagueFingerprint {
  fingerprint_id: string;
  league_name: string;
  sport: string;
  source_document: {
    filename: string;
    uploaded_at: string;
    file_size_bytes: number;
  };
 
  // Processing state
  state: {
    extracted_raw: {
      confidence_score: number;
      extracted_at: string;
      fields: Record<string, any>;
    };
    extracted_enhanced: {
      quality_score: number;
      enhanced_at: string;
      data_quality_report: any;
      enhancement_data: any;
    };
  };
 
  // Partnership evaluation
  partnership_score: {
    overall_score: number;
    tier: string;
    calculated_at: string;
    components: {
      market_size: number;
      data_quality: number;
      integration_readiness: number;
      betting_potential: number;
      strategic_fit: number;
    };
  };
 
  // Generated contracts
  contracts: {
    conservative: ContractDetails;
    balanced: ContractDetails;
    aggressive: ContractDetails;
    premium: ContractDetails;
  };
 
  // External integrations
  google_drive: {
    folder_id: string;
    folder_url: string;
    documents: Record<string, string>;
  };
 
  jira: {
    card_key: string;
    card_url: string;
    created_at: string;
  };
}

interface PipelineExecution {
  pipeline_id: string;
  batch_id?: string;
  fingerprint_id: string;
 
  status: 'success' | 'failed' | 'running';
  stages: {
    extraction: StageMetrics;
    research: StageMetrics;
    scoring: StageMetrics;
    contracts: StageMetrics;
    google_drive: StageMetrics;
    jira: StageMetrics;
  };
 
  total_duration_seconds: number;
  total_cost_usd: number;
 
  created_at: string;
  completed_at?: string;
}
 
interface StageMetrics {
  status: 'pending' | 'running' | 'completed' | 'failed';
  duration_seconds?: number;
  cost_usd?: number;
  error_message?: string;
}

{
  "success": true,
  "data": { ... },
  "metadata": {
    "timestamp": "2024-01-01T12:00:00Z",
    "request_id": "req_12345",
    "version": "v1.0.0"
  }
}

{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid input parameters",
    "details": { ... },
    "suggestion": "Check input format and required fields"
  },
  "metadata": {
    "timestamp": "2024-01-01T12:00:00Z",
    "request_id": "req_12345"
  }
}

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 950
X-RateLimit-Reset: 1640995200
X-RateLimit-Retry-After: 60

{
  "data": [...],
  "pagination": {
    "has_more": true,
    "next_cursor": "cursor_12345",
    "total_count": 1250
  }
}

GET /api/v1/leagues?limit=50&cursor=cursor_12345

# Simple filter
GET /api/v1/leagues?sport_category=soccer
 
# Complex filter
GET /api/v1/leagues?sport_category=soccer&status=active&min_events=10
 
# Date range filter
GET /api/v1/leagues?created_after=2024-01-01&created_before=2024-12-31

# Single field sort
GET /api/v1/leagues?sort=name
 
# Multiple field sort
GET /api/v1/leagues?sort=name,-created_at
 
# Descending sort
GET /api/v1/leagues?sort=-total_events

X-API-Version: v1.0.0
X-API-Deprecation-Date: 2025-12-31

from altsportsleagues import Client
 
client = Client(api_key="your-api-key")
 
# Get league data
leagues = client.leagues.list(sport_category="soccer")
 
# Generate contract
contract = client.contracts.generate({
    "league_name": "Premier League",
    "tier": "premium",
    "duration_months": 12
})

import { AltSportsLeagues } from '@altsportsleagues/sdk';
 
const client = new AltSportsLeagues({
  apiKey: 'your-api-key'
});
 
// Async operations
const leagues = await client.leagues.list({
  sportCategory: 'soccer'
});
 
const intelligence = await client.intelligence.query({
  query: 'What are the betting trends for NBA?',
  stream: true
});

# Health check
curl -X GET "https://api.altsportsleagues.ai/api/v1/core/health" \
  -H "Authorization: Bearer your-jwt-token"
 
# List leagues
curl -X GET "https://api.altsportsleagues.ai/api/v1/leagues" \
  -H "Authorization: Bearer your-jwt-token" \
  -H "Content-Type: application/json"
 
# Create contract
curl -X POST "https://api.altsportsleagues.ai/api/v1/business/contracts/generate" \
  -H "Authorization: Bearer your-jwt-token" \
  -H "Content-Type: application/json" \
  -d '{
    "league_name": "Canadian Premier League",
    "tier": "premium",
    "duration_months": 12
  }'

{
  "url": "https://your-app.com/webhook",
  "events": ["league.created", "contract.generated", "email.processed"],
  "secret": "your-webhook-secret"
}

# Use sandbox for testing
curl -X GET "https://sandbox-api.altsportsleagues.ai/api/v1/core/health"

interface LeagueQuestionnaire {
  league_name: string;              // Official league name
  sport_type: string;               // Type of sport
  contact_name: string;             // Primary contact person
  contact_email: string;            // Contact email address
  contact_title?: string;           // Job title (optional)
  participant_count: number;        // Number of teams/participants
  fan_base_size: number;            // Estimated fan base
  geographic_scope: string;         // Local, regional, national, international
  years_operating: number;          // Years in operation
  has_api: boolean;                 // API availability
  budget_range: string;             // premium, standard, budget
  partnership_goals: string[];      // Array of partnership objectives
  data_quality_score?: number;      // Auto-calculated quality score
}

const questionnaire: LeagueQuestionnaire = {
  league_name: "Elite Soccer League",
  sport_type: "soccer",
  contact_name: "John Smith",
  contact_email: "john@esl.com",
  contact_title: "VP Business Development",
  participant_count: 32,
  fan_base_size: 2000000,
  geographic_scope: "international",
  years_operating: 8,
  has_api: true,
  budget_range: "premium",
  partnership_goals: ["sponsorship", "broadcasting", "merchandise"]
};

interface TierClassification {
  league_id: string;
  tier: "platinum" | "gold" | "silver" | "bronze";
  score: number;                    // 0.80-1.00 = Platinum
  market_size_score: number;        // Geographic coverage (25% weight)
  data_quality_score: number;       // Data completeness (20% weight)
  integration_score: number;        // Technical readiness (20% weight)
  betting_potential_score: number;  // Revenue potential (20% weight)
  strategic_fit_score: number;      // Partnership alignment (15% weight)
  confidence_level: number;         // AI confidence in classification
  recommended_actions: string[];    // Next steps for the league
  classification_date: string;      // ISO timestamp
}

interface ContractTerms {
  contract_id: string;
  league_id: string;
  partner_id: string;
  contract_type: "sponsorship" | "broadcasting" | "data_licensing" | "merchandise";
  tier: "platinum" | "gold" | "silver" | "bronze";
  flavor: "conservative" | "balanced" | "aggressive" | "premium";
  duration_months: number;           // 12, 24, 36, or 48
  revenue_share_percentage: number;  // 0%, 5%, 10%, or 15%
  base_fee: number;                  // Base contract value
  total_value: number;               // Calculated total contract value
  deliverables: ContractDeliverable[];
  payment_terms: PaymentTerms;
  termination_clauses: TerminationClause[];
  effective_date: string;
  expiration_date: string;
}
 
interface ContractDeliverable {
  id: string;
  type: string;
  description: string;
  quantity?: number;
  frequency?: string;
  quality_standards: string[];
}

interface NegotiationPackage {
  package_id: string;
  league_id: string;
  partner_id: string;
  status: "draft" | "sent" | "negotiating" | "accepted" | "rejected";
  proposal_date: string;
  contract_terms: ContractTerms;
  market_analysis: MarketAnalysis;
  competitive_intelligence: CompetitiveIntelligence;
  financial_projections: FinancialProjection[];
  risk_assessment: RiskAssessment;
  negotiation_history: NegotiationEvent[];
  next_steps: string[];
}
 
interface MarketAnalysis {
  market_size: number;
  growth_rate: number;
  competitive_landscape: string;
  target_demographics: DemographicProfile;
  revenue_potential: RevenueProjection;
}

interface UnifiedOutput {
  league_id: string;
  questionnaire: LeagueQuestionnaire;
  tier_classification: TierClassification;
  market_intelligence: MarketIntelligence;
  partnership_opportunities: PartnershipOpportunity[];
  risk_profile: RiskProfile;
  financial_projections: FinancialProjection;
  technical_readiness: TechnicalReadiness;
  last_updated: string;
  data_quality_score: number;
  intelligence_confidence: number;
}

// Automatic validation on API calls
app.post('/api/v1/leagues/questionnaire', async (req, res) => {
  try {
    const questionnaire = LeagueQuestionnaireSchema.parse(req.body);
    // Data is now validated and typed
    await processQuestionnaire(questionnaire);
    res.json({ success: true });
  } catch (error) {
    res.status(400).json({
      error: 'Validation failed',
      details: error.errors
    });
  }
});

{{schema:schemaName}}                    # Inject TypeScript interface (default)
{{schema:schemaName(format=python)}}     # Inject Python Pydantic model
{{schema:schemaName(format=json)}}       # Inject JSON schema
{{schema:schemaName(showExamples=true)}} # Include usage examples
{{schema:schemaName(showValidation=true)}} # Include validation rules
{{schema:schemaName(includeMetadata=true)}} # Include schema metadata