Less (Felipe de Loyola)

Overview

Less, founded in 2024, provides an esports data API designed for developers requiring access to player statistics, match data, and tournament information across various esports titles. The platform's core products include a Player statistics API, a Match data API, and a Tournament data API, all accessible via a RESTful interface. Less is particularly suited for applications such as esports fantasy leagues, betting platforms, and tools for player performance analytics and content creation.

Developers can integrate Less data to power features like real-time player leaderboards, historical match analysis, and upcoming tournament schedules. The API delivers structured data that can be consumed by web and mobile applications, backend services, or data analysis pipelines. For instance, a fantasy league platform could use the Player statistics API to track individual player KDA (kills, deaths, assists) in League of Legends or ACS (Average Combat Score) in VALORANT, updating scores as matches progress. Similarly, a betting platform might utilize the Match data API to display odds and results for specific esports events, drawing on historical data to inform predictive models.

The developer experience with Less is supported by clear documentation and code examples, alongside SDKs for Python and Node.js. This simplifies the process of making API calls and parsing responses. The developer dashboard offers tools for managing API keys and monitoring usage, providing insights into request volumes and data consumption. This allows developers to track their API usage against plan limits and identify potential areas for optimization. The service aims to offer a reliable source of structured esports data, enabling developers to focus on building their applications rather than on data collection and parsing from disparate sources like Liquipedia's Counter-Strike wiki or HLTV.org match pages.

Less adheres to GDPR compliance standards, ensuring data privacy and protection for its users. This commitment to compliance is relevant for platforms operating within regions subject to these regulations. The API's design focuses on providing specific endpoints for different data types, such as retrieving a list of active players for a given game, fetching detailed statistics for a particular match, or querying information about ongoing or past tournaments. This granular access allows developers to request only the data they need, contributing to efficient API usage.

Key features

• Player Statistics API: Provides detailed performance metrics for individual players across supported esports titles, including historical data and real-time updates. This can include KDA, win rates, specific champion/agent statistics, and more, depending on the game.
• Match Data API: Offers comprehensive information on esports matches, including team rosters, scores, game states, and event timelines. This allows for detailed post-match analysis or real-time score updates.
• Tournament Data API: Delivers schedules, brackets, participating teams, and results for various esports tournaments globally. This is crucial for tracking event progress and providing context for matches.
• RESTful API: Utilizes standard HTTP methods and JSON responses, making it compatible with a wide range of programming languages and environments.
• SDKs for Python and Node.js: Pre-built libraries simplify API integration and interaction for common development stacks, reducing boilerplate code.
• Developer Dashboard: A web interface for managing API keys, monitoring API usage, and accessing documentation. This centralizes administrative tasks and provides usage analytics.
• GDPR Compliance: Ensures data handling practices meet General Data Protection Regulation standards, addressing privacy concerns for users in relevant jurisdictions.

Pricing

Less offers a tiered pricing structure, including a free developer plan and progressively larger paid plans, with custom options for enterprise-level usage. Pricing is accurate as of May 2026.

For more detailed information on features included with each plan and specific terms, refer to the official Less pricing page.

Common integrations

• Esports Fantasy League Platforms: Integrate player and match data to power scoring, drafts, and league management.
• Esports Betting Platforms: Utilize real-time match data and historical statistics for odds generation, live betting updates, and result validation.
• Content Creation Tools: Fetch tournament schedules and player statistics to generate articles, videos, or infographics for esports news sites and content creators.
• Player Performance Analytics Dashboards: Incorporate detailed player statistics to build tools for professional teams, coaches, or individual players to analyze performance and identify trends.
• Gaming Community Applications: Display live scores, upcoming matches, and player profiles within community hubs or fan applications.
• Data Warehouses and Analytics Pipelines: Extract esports data for long-term storage and advanced analytical processing using tools like Apache Kafka or AWS Kinesis.

Alternatives

• PandaScore: Offers a comprehensive esports data API covering a wide range of games with detailed statistics and odds.
• Abios: Provides esports data solutions, including API services for schedules, results, and statistics, often catering to media and betting industries.
• Matcherino: A platform focused on esports tournament organization and prize pool management, with some data capabilities related to event outcomes.
• TheSpike.gg API: Primarily focused on VALORANT esports data, offering statistics and match information specific to that title.

Getting started

To begin using the Less API, developers typically sign up for an account on the Less website to obtain an API key. Once the API key is secured, you can make authenticated requests to the various endpoints. Below is a Python example demonstrating how to fetch recent Counter-Strike match data using the Less API. This example assumes you have the requests library installed and have replaced YOUR_API_KEY with your actual Less API key.

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.less.gg/v1"

def get_recent_cs_matches():
    headers = {
        "Authorization": f"Bearer {API_KEY}"
    }
    params = {
        "game": "counter-strike",
        "status": "finished",
        "limit": 5
    }
    try:
        response = requests.get(f"{BASE_URL}/matches", headers=headers, params=params)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        matches = response.json()
        if matches:
            print("Recent Counter-Strike Matches:")
            for match in matches['data']:
                print(f"  Match ID: {match['id']}")
                print(f"  Team 1: {match['team1']['name']} vs Team 2: {match['team2']['name']}")
                print(f"  Score: {match['score']['team1']} - {match['score']['team2']}")
                print(f"  Tournament: {match['tournament']['name']}")
                print("---")
        else:
            print("No recent Counter-Strike matches found.")
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")

if __name__ == "__main__":
    get_recent_cs_matches()

This script demonstrates how to authenticate a request with your API key, specify query parameters for filtering matches by game and status, and parse the JSON response. The example fetches the 5 most recently finished Counter-Strike matches, printing out key details for each. For more detailed API usage and available endpoints, consult the Less API reference documentation.