> ## Documentation Index
> Fetch the complete documentation index at: https://docs.teamfortuna.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Astra API rate limits and responsible usage guide

> Learn how to use the Astra API responsibly, cache responses effectively, and avoid hitting usage limits with smart request patterns.

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.

<Note>
  Astra is a free community API. Use it responsibly to help keep it available for everyone.
</Note>

## 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](/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](/concepts/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:

```python theme={null}
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.

<Tip>
  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.
</Tip>