Skip to main content
Astra is a free, community-maintained API with no authentication keys or paid tiers. Because it runs on shared infrastructure, how you use it directly affects availability for everyone. Following the patterns on this page keeps the API fast and reliable for all developers.
Astra is a free community API. Use it responsibly to help keep it available for everyone.

​
Best practices

Use a descriptive User-Agent. Include your app name, version, and a URL so the Astra team can identify your integration and contact you if your requests are causing issues. See authentication for the required format. Cache responses locally. Valorant game data — agents, weapons, maps, sprays — rarely changes outside of patch days. Storing responses locally and reusing them avoids redundant requests and significantly reduces your API usage. Use /v1/version to check for updates. Instead of re-fetching all assets on a schedule, poll the version endpoint and only re-fetch when the version field changes. See versioning for a full example. Request only the locale(s) you need. If your app targets one region, pass ?language=<locale> rather than ?language=all. Fetching all locales returns larger payloads and should only be used when you genuinely need every translation. Fetch by UUID when possible. If you know the UUID of a specific resource, fetch it directly (e.g. /v1/agents/{uuid}) rather than listing all resources and filtering client-side. Targeted requests are faster and generate less load.

​
Efficient request patterns

Use this pattern to avoid unnecessary requests on every application startup or scheduled task: 
import requests
import json
import os

HEADERS = {"User-Agent": "my-app/1.0.0 (+https://example.com)"}
BASE_URL = "https://astra.teamfortuna.xyz"
CACHE_FILE = "cache.json"

def load_cache():
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE) as f:
            return json.load(f)
    return {}

def save_cache(data):
    with open(CACHE_FILE, "w") as f:
        json.dump(data, f)

def get_agents():
    cache = load_cache()

    # 1. Fetch current version (lightweight request)
    version_resp = requests.get(f"{BASE_URL}/v1/version", headers=HEADERS)
    current_version = version_resp.json()["data"]["version"]

    # 2. Compare with cached version
    if cache.get("version") == current_version and "agents" in cache:
        # Cache is still valid — no re-fetch needed
        return cache["agents"]

    # 3. Version changed — re-fetch asset data
    agents_resp = requests.get(f"{BASE_URL}/v1/agents", headers=HEADERS)
    agents = agents_resp.json()["data"]

    # 4. Update cache
    save_cache({"version": current_version, "agents": agents})

    return agents
The same pattern applies to any expensive resource: fetch the version first, compare it to what you stored last time, and only hit the data endpoints when something has actually changed.
Most game asset data only changes on patch day. A cache TTL of 24 hours is a safe default for agents, maps, and weapons — combine it with version-based invalidation for best results.