DepotBox API Documentation

Your programmatic gateway to searching and downloading Steam manifest data.

Your key stays in this browser tab only — it is never sent to DepotBox or stored on disk. Every YOUR_KEY_HERE below is replaced with it instantly, so you can copy-paste working commands.

Quick Start — Download a Game

The fastest thing the API can do is hand you a ready-to-use .zip for a Steam AppID in one single request. No tokens, no polling, no SDK. Pick your tool below — every snippet is complete and runnable as-is.

1
Get a key

Buy one on the Pricing page, then copy it from your Dashboard.

2
Pick an AppID

The number in a Steam store URL. store.steampowered.com/app/70/ → AppID 70.

3
Call one endpoint

Hit /api/direct-download and write the response body to a file. That file is the ZIP.

Download AppID 70 as a ZIP

# Just paste this into your address bar and press Enter.
# The browser downloads the ZIP like any normal file link.

https://depotbox.lol/api/direct-download?appid=70&api_key=YOUR_KEY_HERE
curl -L "https://depotbox.lol/api/direct-download?appid=70" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -o "70.zip"
Invoke-WebRequest -Uri "https://depotbox.lol/api/direct-download?appid=70" `
  -Headers @{ "X-API-Key" = "YOUR_KEY_HERE" } `
  -OutFile "70.zip"
# pip install requests
import requests

API_KEY = "YOUR_KEY_HERE"
APPID = "70"

with requests.get(
    "https://depotbox.lol/api/direct-download",
    params={"appid": APPID},
    headers={"X-API-Key": API_KEY},
    stream=True,          # stream: the ZIP can be large
    timeout=(10, 900),    # (connect, read) — generation can take minutes
) as r:
    r.raise_for_status()
    with open(f"{APPID}.zip", "wb") as f:
        for chunk in r.iter_content(chunk_size=64 * 1024):
            f.write(chunk)

print(f"Saved {APPID}.zip")
// Node 18+ — no dependencies needed
import { createWriteStream } from 'node:fs';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';

const API_KEY = 'YOUR_KEY_HERE';
const appid = '70';

const res = await fetch(`https://depotbox.lol/api/direct-download?appid=${appid}`, {
  headers: { 'X-API-Key': API_KEY }
});

if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);

await pipeline(Readable.fromWeb(res.body), createWriteStream(`${appid}.zip`));
console.log(`Saved ${appid}.zip`);
// Java 11+ — java.net.http, no external libraries
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;

public class DepotBoxDownload {
    public static void main(String[] args) throws Exception {
        String apiKey = "YOUR_KEY_HERE";
        String appid  = "70";

        HttpClient client = HttpClient.newBuilder()
                .followRedirects(HttpClient.Redirect.NORMAL)
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://depotbox.lol/api/direct-download?appid=" + appid))
                .header("X-API-Key", apiKey)
                .timeout(Duration.ofMinutes(15))
                .GET()
                .build();

        Path out = Path.of(appid + ".zip");
        HttpResponse<Path> response =
                client.send(request, HttpResponse.BodyHandlers.ofFile(out));

        if (response.statusCode() != 200) {
            throw new RuntimeException("Download failed: HTTP " + response.statusCode()
                    + " — " + java.nio.file.Files.readString(out));
        }
        System.out.println("Saved " + out.toAbsolutePath());
    }
}
// .NET 6+
using System.Net.Http;

var apiKey = "YOUR_KEY_HERE";
var appid  = "70";

using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(15) };
http.DefaultRequestHeaders.Add("X-API-Key", apiKey);

using var resp = await http.GetAsync(
    $"https://depotbox.lol/api/direct-download?appid={appid}",
    HttpCompletionOption.ResponseHeadersRead);

resp.EnsureSuccessStatusCode();

await using var file = File.Create($"{appid}.zip");
await resp.Content.CopyToAsync(file);

Console.WriteLine($"Saved {appid}.zip");
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

func main() {
	apiKey, appid := "YOUR_KEY_HERE", "70"

	req, _ := http.NewRequest("GET",
		"https://depotbox.lol/api/direct-download?appid="+appid, nil)
	req.Header.Set("X-API-Key", apiKey)

	client := &http.Client{Timeout: 15 * time.Minute}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		panic(fmt.Sprintf("HTTP %d: %s", resp.StatusCode, body))
	}

	out, _ := os.Create(appid + ".zip")
	defer out.Close()
	io.Copy(out, resp.Body)

	fmt.Println("Saved " + appid + ".zip")
}
<?php
$apiKey = 'YOUR_KEY_HERE';
$appid  = '70';

$ch = curl_init("https://depotbox.lol/api/direct-download?appid={$appid}");
$fp = fopen("{$appid}.zip", 'wb');

curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ["X-API-Key: {$apiKey}"],
    CURLOPT_FILE           => $fp,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_TIMEOUT        => 900,
]);

curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
fclose($fp);

echo $status === 200 ? "Saved {$appid}.zip\n" : "Failed: HTTP {$status}\n";
wget --header="X-API-Key: YOUR_KEY_HERE" \
  "https://depotbox.lol/api/direct-download?appid=70" \
  -O "70.zip"
Only need the .lua file?

Swap /api/direct-download for /api/direct-lua in any snippet above and save it as 70.lua instead. Everything else is identical — see Lua Generation.

How long does it take?

The server builds your ZIP while the request is open, so the response does not start arriving immediately. Small games return in a few seconds; large ones with many depots can take a minute or more. Set a generous read timeout (10–15 minutes is safe) in whatever HTTP client you use — the most common integration bug is a default 30-second timeout killing a request that was working fine.

If you would rather not hold a connection open at all — for example in a web app where the user is waiting — use the asynchronous flow instead: fire one request, get a token back instantly, poll for progress, then download.

Authentication & Basics

Base URL

Every endpoint on this page is relative to:

https://depotbox.lol

Two ways to send your API key

Almost every endpoint requires a key. You can buy one on the Pricing page and manage it in your Dashboard. Send it either way — the server accepts both:

MethodHowBest for
Header (recommended) X-API-Key: YOUR_KEY_HERE Scripts, servers, apps — anything you control.
Query string ?api_key=YOUR_KEY_HERE Browsers, download managers, IDM/JDownloader, <a href> links, anything that can only open a URL.

Header style (curl):

curl "https://depotbox.lol/api/games/70/availability" \
  -H "X-API-Key: YOUR_KEY_HERE"

URL style (paste straight into a browser):

https://depotbox.lol/api/games/70/availability?api_key=YOUR_KEY_HERE
When not to use ?api_key=

URLs get written to browser history, server access logs, proxy logs and Referer headers. Use the query-string form for your own manual downloads, and the X-API-Key header everywhere else. Never put a key in a URL you paste into a public chat, a bug report, or a shared script — if you do, rotate the key from your Dashboard (the old key keeps working for 1 hour, then dies).

Calling the API from front-end JavaScript won't work

DepotBox does not send CORS headers, so a fetch() from a web page on another domain will be blocked by the browser. This is deliberate — it also stops your key leaking to every visitor. Call the API from your backend and pass the result to your front-end. Pasting an API URL directly into the address bar is not affected by CORS and works fine.

Rate limiting

Each key has a per-minute limit set by its plan: Starter = 60 requests/minute, Pro = 120 requests/minute. Going over returns 429 Too Many Requests with the number of seconds until the window resets:

{
  "error": "Too Many Requests: API Key limit (60 requests/minute) exceeded. Try again in 34 seconds."
}

Need more throughput? Buy an additional key from the Pricing page.

Optional: IP whitelist

You can restrict a key to specific IP addresses in your Dashboard. If the whitelist is non-empty and your request comes from another address, you get 403 Forbidden naming the rejected IP. Leave it empty to allow any IP.

Which download flow should I use?

FlowShapeUse it when
Direct 1 request → the file itself Scripts, cron jobs, CLI tools, browser downloads. Simplest thing that works.
Async 1 request → token → poll → link Web apps and bots, where a user is watching and you want a progress bar instead of a frozen spinner.
Lua-only Either shape, but returns .lua You only need the Lua script — no .manifest files, no ZIP wrapper.

Direct Download — one request, one file

These endpoints do all the work inside a single request and send the finished .zip back as the response body. There is no JSON to parse and nothing to poll: whatever bytes come back are the file. This is the flow to use for curl, scripts, cron jobs, download managers, and pasting a URL into a browser.

Reading the response correctly

On success you get 200 OK with Content-Type: application/zip and a Content-Disposition filename. On failure you get a non-200 status with a small JSON body instead. So: check the status code before you trust the bytes. If you blindly save the body on a 404 you end up with a "ZIP" that is really a one-line error message.

GET /api/direct-download?appid= browser-friendly returns a file

The simplest endpoint in the whole API. Everything travels in the URL, so anything that can open a link can download a depot package — browsers, wget, IDM, JDownloader, an <a href> in your own app.

Query Parameters:

ParameterTypeRequiredDescription
appidstringYesThe Steam AppID to package.
api_keystringYes** Only if you are not sending the X-API-Key header.

Paste this into your browser's address bar:

https://depotbox.lol/api/direct-download?appid=70&api_key=YOUR_KEY_HERE

The download starts immediately, named 70.zip. Bookmark it, right-click → Save link as…, or drop it into a download manager — it behaves like any other file URL.

Same request, every other way:

curl -L "https://depotbox.lol/api/direct-download?appid=70" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  --fail \
  -o "70.zip"

# --fail makes curl exit non-zero (and write no file) on 4xx/5xx
# instead of happily saving the JSON error as "70.zip".
try {
    Invoke-WebRequest -Uri "https://depotbox.lol/api/direct-download?appid=70" `
        -Headers @{ "X-API-Key" = "YOUR_KEY_HERE" } `
        -TimeoutSec 900 `
        -OutFile "70.zip"
    Write-Host "Saved 70.zip"
} catch {
    Write-Error "Download failed: $($_.Exception.Message)"
}
import requests

BASE = "https://depotbox.lol"
HEADERS = {"X-API-Key": "YOUR_KEY_HERE"}


def download_zip(appid: str, out_path: str | None = None) -> str:
    out_path = out_path or f"{appid}.zip"

    with requests.get(
        f"{BASE}/api/direct-download",
        params={"appid": appid},
        headers=HEADERS,
        stream=True,
        timeout=(10, 900),
    ) as r:
        if r.status_code != 200:
            # Errors come back as JSON, not as a file
            raise RuntimeError(f"{r.status_code}: {r.text[:300]}")

        with open(out_path, "wb") as f:
            for chunk in r.iter_content(chunk_size=64 * 1024):
                f.write(chunk)

    return out_path


print("Saved", download_zip("70"))
import { createWriteStream } from 'node:fs';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';

const BASE = 'https://depotbox.lol';
const API_KEY = 'YOUR_KEY_HERE';

async function downloadZip(appid, outPath = `${appid}.zip`) {
  const res = await fetch(`${BASE}/api/direct-download?appid=${appid}`, {
    headers: { 'X-API-Key': API_KEY }
  });

  if (!res.ok) {
    // Errors come back as JSON, not as a file
    throw new Error(`${res.status}: ${await res.text()}`);
  }

  await pipeline(Readable.fromWeb(res.body), createWriteStream(outPath));
  return outPath;
}

console.log('Saved', await downloadZip('70'));
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;

public class DepotBox {

    private static final String BASE    = "https://depotbox.lol";
    private static final String API_KEY = "YOUR_KEY_HERE";

    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .connectTimeout(Duration.ofSeconds(20))
            .build();

    public static Path downloadZip(String appid) throws Exception {
        HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create(BASE + "/api/direct-download?appid=" + appid))
                .header("X-API-Key", API_KEY)
                .timeout(Duration.ofMinutes(15))
                .GET()
                .build();

        // Buffer first so a JSON error never gets written to disk as a .zip
        HttpResponse<byte[]> res =
                CLIENT.send(req, HttpResponse.BodyHandlers.ofByteArray());

        if (res.statusCode() != 200) {
            throw new RuntimeException("HTTP " + res.statusCode() + ": "
                    + new String(res.body()));
        }

        Path out = Path.of(appid + ".zip");
        Files.write(out, res.body());
        return out;
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Saved " + downloadZip("70").toAbsolutePath());
    }
}
using System.Net.Http;

const string Base   = "https://depotbox.lol";
const string ApiKey = "YOUR_KEY_HERE";

static async Task<string> DownloadZipAsync(string appid)
{
    using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(15) };
    http.DefaultRequestHeaders.Add("X-API-Key", ApiKey);

    using var resp = await http.GetAsync(
        $"{Base}/api/direct-download?appid={appid}",
        HttpCompletionOption.ResponseHeadersRead);

    if (!resp.IsSuccessStatusCode)
        throw new Exception($"{(int)resp.StatusCode}: {await resp.Content.ReadAsStringAsync()}");

    var path = $"{appid}.zip";
    await using var file = File.Create(path);
    await resp.Content.CopyToAsync(file);
    return path;
}

Console.WriteLine($"Saved {await DownloadZipAsync("70")}");
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

const base = "https://depotbox.lol"
const apiKey = "YOUR_KEY_HERE"

func downloadZip(appid string) (string, error) {
	req, err := http.NewRequest("GET", base+"/api/direct-download?appid="+appid, nil)
	if err != nil {
		return "", err
	}
	req.Header.Set("X-API-Key", apiKey)

	client := &http.Client{Timeout: 15 * time.Minute}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return "", fmt.Errorf("HTTP %d: %s", resp.StatusCode, body)
	}

	path := appid + ".zip"
	out, err := os.Create(path)
	if err != nil {
		return "", err
	}
	defer out.Close()

	_, err = io.Copy(out, resp.Body)
	return path, err
}

func main() {
	path, err := downloadZip("70")
	if err != nil {
		panic(err)
	}
	fmt.Println("Saved " + path)
}
wget --content-disposition \
  --header="X-API-Key: YOUR_KEY_HERE" \
  "https://depotbox.lol/api/direct-download?appid=70"

# --content-disposition lets the server pick the filename (70.zip).
<!-- Works because the key travels in the URL.
     Only do this on a page nobody else can see: anyone who
     views the source can read your key. -->

<a href="https://depotbox.lol/api/direct-download?appid=70&api_key=YOUR_KEY_HERE"
   download>
  Download Half-Life (AppID 70)
</a>

POST /api/direct-download returns a file

Identical behaviour, with the AppID in a JSON body instead of the query string. Use this when you would rather not have the AppID show up in logs, or when your HTTP client makes POST bodies more natural than URL building.

Request Body:

ParameterTypeRequiredDescription
appidstringYesThe Steam AppID to package.
curl -X POST "https://depotbox.lol/api/direct-download" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appid": "70" }' \
  --fail \
  -o "Half-Life-70.zip"
import requests

with requests.post(
    "https://depotbox.lol/api/direct-download",
    json={"appid": "70"},
    headers={"X-API-Key": "YOUR_KEY_HERE"},
    stream=True,
    timeout=(10, 900),
) as r:
    if r.status_code != 200:
        raise RuntimeError(f"{r.status_code}: {r.text[:300]}")

    with open("Half-Life-70.zip", "wb") as f:
        for chunk in r.iter_content(chunk_size=64 * 1024):
            f.write(chunk)
import { createWriteStream } from 'node:fs';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';

const res = await fetch('https://depotbox.lol/api/direct-download', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'YOUR_KEY_HERE'
  },
  body: JSON.stringify({ appid: '70' })
});

if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);

await pipeline(Readable.fromWeb(res.body), createWriteStream('Half-Life-70.zip'));
HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://depotbox.lol/api/direct-download"))
        .header("X-API-Key", "YOUR_KEY_HERE")
        .header("Content-Type", "application/json")
        .timeout(Duration.ofMinutes(15))
        .POST(HttpRequest.BodyPublishers.ofString("{\"appid\":\"70\"}"))
        .build();

HttpResponse<byte[]> res =
        CLIENT.send(req, HttpResponse.BodyHandlers.ofByteArray());

if (res.statusCode() != 200) {
    throw new RuntimeException("HTTP " + res.statusCode()
            + ": " + new String(res.body()));
}

Files.write(Path.of("Half-Life-70.zip"), res.body());
using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(15) };
http.DefaultRequestHeaders.Add("X-API-Key", "YOUR_KEY_HERE");

var body = new StringContent(
    "{\"appid\":\"70\"}", System.Text.Encoding.UTF8, "application/json");

using var resp = await http.PostAsync(
    "https://depotbox.lol/api/direct-download", body);

if (!resp.IsSuccessStatusCode)
    throw new Exception($"{(int)resp.StatusCode}: {await resp.Content.ReadAsStringAsync()}");

await using var file = File.Create("Half-Life-70.zip");
await resp.Content.CopyToAsync(file);

GET POST /api/direct-download/batch returns a file

Packages up to 50 AppIDs into one ZIP, still in a single request. The result is named DepotBox_Direct_Batch_xxxxxxxx.zip. Any AppID that could not be built is skipped and listed inside the archive in excluded_manifests.txt — so a partial failure still gives you a usable file rather than an error.

Parameters:

ParameterGET (query)POST (JSON body)Description
appids Comma-separated: ?appids=70,220 Array: ["70","220"] Required. Max 50 per request.
mergeFolders &mergeFolders=true true / false Optional. Flatten everything into one folder instead of one folder per game.
onlyfiles &onlyfiles=true GET only Optional. Drop the per-game folder structure entirely — loose files at the ZIP root.

Browser / URL form:

https://depotbox.lol/api/direct-download/batch?appids=70,220,440&api_key=YOUR_KEY_HERE
# GET form — comma-separated list in the URL
curl -L "https://depotbox.lol/api/direct-download/batch?appids=70,220,440" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  --fail -o "My_Batch.zip"

# POST form — JSON array, with folders merged
curl -X POST "https://depotbox.lol/api/direct-download/batch" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appids": ["70", "220", "440"], "mergeFolders": true }' \
  --fail -o "My_Batch.zip"
import requests

APPIDS = ["70", "220", "440"]  # max 50

with requests.post(
    "https://depotbox.lol/api/direct-download/batch",
    json={"appids": APPIDS, "mergeFolders": False},
    headers={"X-API-Key": "YOUR_KEY_HERE"},
    stream=True,
    timeout=(10, 1800),   # batches take longer — be generous
) as r:
    if r.status_code != 200:
        raise RuntimeError(f"{r.status_code}: {r.text[:300]}")

    with open("My_Batch.zip", "wb") as f:
        for chunk in r.iter_content(chunk_size=64 * 1024):
            f.write(chunk)

print("Saved My_Batch.zip — check excluded_manifests.txt inside for skipped games")
import { createWriteStream } from 'node:fs';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';

const appids = ['70', '220', '440']; // max 50

const res = await fetch('https://depotbox.lol/api/direct-download/batch', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'YOUR_KEY_HERE'
  },
  body: JSON.stringify({ appids, mergeFolders: false })
});

if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);

await pipeline(Readable.fromWeb(res.body), createWriteStream('My_Batch.zip'));
String appids = String.join(",", "70", "220", "440"); // max 50

HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://depotbox.lol/api/direct-download/batch?appids=" + appids))
        .header("X-API-Key", "YOUR_KEY_HERE")
        .timeout(Duration.ofMinutes(30))
        .GET()
        .build();

HttpResponse<byte[]> res =
        CLIENT.send(req, HttpResponse.BodyHandlers.ofByteArray());

if (res.statusCode() != 200) {
    throw new RuntimeException("HTTP " + res.statusCode()
            + ": " + new String(res.body()));
}

Files.write(Path.of("My_Batch.zip"), res.body());
var appids = string.Join(",", new[] { "70", "220", "440" }); // max 50

using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(30) };
http.DefaultRequestHeaders.Add("X-API-Key", "YOUR_KEY_HERE");

using var resp = await http.GetAsync(
    $"https://depotbox.lol/api/direct-download/batch?appids={appids}",
    HttpCompletionOption.ResponseHeadersRead);

if (!resp.IsSuccessStatusCode)
    throw new Exception($"{(int)resp.StatusCode}: {await resp.Content.ReadAsStringAsync()}");

await using var file = File.Create("My_Batch.zip");
await resp.Content.CopyToAsync(file);
Batches are slow by nature

50 games are built one after another before a single byte is sent. If your client, proxy or reverse proxy has a short idle timeout, the connection can drop mid-build. For large batches prefer the async flow, which returns instantly and lets you poll.

Async Download — start, poll, fetch

Instead of holding one long connection open, the async flow splits the work into three quick requests. Nothing ever hangs, you get live progress logs to show a user, and the final link is a plain URL you can hand to a browser. Use this in web apps, Discord bots, and anywhere a 15-minute request would be unacceptable.

1
Start

POST /api/download → returns a token instantly (202).

2
Poll

GET /api/status/:token every 2–3s until status is completed.

3
Fetch

GET the download_link from step 2. That's your ZIP.

Steps 2 and 3 need no API key

Only the first call (POST /api/download) spends a request from your rate limit and requires authentication. The token itself is the credential for polling and downloading, which means you can hand download_link straight to a user's browser, a Discord message, or an <a> tag without ever exposing your key.

POST /api/download

Starts building the package for one AppID and returns immediately. Nothing is downloaded yet.

Request Body:

ParameterTypeRequiredDescription
appidstringYesThe Steam AppID to package.

Example Request:

curl -X POST "https://depotbox.lol/api/download" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appid": "70" }'

Example Response (202 Accepted):

{
  "status": "processing",
  "token": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "polling_url": "/api/status/a1b2c3d4-e5f6-7890-1234-567890abcdef"
}

POST /api/download/batch

Same idea for up to 50 AppIDs. Returns one token covering the whole batch.

Request Body:

ParameterTypeRequiredDescription
appidsarray of stringsYesUp to 50 AppIDs.
mergeFoldersbooleanNoFlatten everything into one folder. Default: false.

Example Request:

curl -X POST "https://depotbox.lol/api/download/batch" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appids": ["70", "220"], "mergeFolders": false }'

GET /api/status/:token no key needed

Poll for progress. Keep calling it until status is completed, completed_with_warnings, or failed. Two to three seconds between polls is plenty.

Response fields:

FieldTypeDescription
statusstringprocessing, completed, completed_with_warnings, failed, or invalid_or_expired.
messagestringHuman-readable current step.
logsarrayProgress log lines — handy for a live status view.
download_linkstringnull until finished, then the full URL to fetch.
finalUserZipNamestringSuggested filename for the result.
expiry_minutesintegerHow long the link stays alive (currently 30 minutes).
failureReasonstringSet when status is failed.

Example Request:

curl "https://depotbox.lol/api/status/a1b2c3d4-e5f6-7890-1234-567890abcdef"

Example "Completed" Response:

{
  "status": "completed",
  "message": "Download completed successfully.",
  "appId": "70",
  "gameName": "Half-Life",
  "logs": ["Fetching depot keys...", "Packaging manifests...", "Done."],
  "finalUserZipName": "Half-Life-70.zip",
  "isBatch": false,
  "download_link": "https://depotbox.lol/api/download/a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "expiry_minutes": 30
}

GET /api/download/:token browser-friendly no key needed returns a file

The finished ZIP. This is exactly the download_link the status endpoint gave you, so in practice you never build this URL by hand — you just follow it. Open it in a browser, pass it to a download manager, or stream it in code. The link is single-purpose and expires after 30 minutes; the temporary files are deleted once you fetch it.

Example Request:

curl -L "https://depotbox.lol/api/download/a1b2c3d4-e5f6-7890-1234-567890abcdef" \
  --fail -o "Half-Life-70.zip"

Complete working examples

All three steps wired together, with polling and a timeout. Copy, paste, run.

# pip install requests
import time
import requests

BASE = "https://depotbox.lol"
API_KEY = "YOUR_KEY_HERE"


def download(appid: str, poll_every: float = 2.0, timeout_s: int = 900) -> str:
    # 1. Start the job (this is the only call that needs your key)
    start = requests.post(
        f"{BASE}/api/download",
        json={"appid": appid},
        headers={"X-API-Key": API_KEY},
        timeout=30,
    )
    start.raise_for_status()
    token = start.json()["token"]
    print(f"Job started: {token}")

    # 2. Poll until it is done
    deadline = time.time() + timeout_s
    while True:
        if time.time() > deadline:
            raise TimeoutError("Gave up waiting for the package")

        status = requests.get(f"{BASE}/api/status/{token}", timeout=30).json()
        state = status.get("status")

        if state in ("completed", "completed_with_warnings"):
            break
        if state in ("failed", "invalid_or_expired"):
            raise RuntimeError(status.get("message") or state)

        print(f"  ... {status.get('message', 'working')}")
        time.sleep(poll_every)

    # 3. Fetch the file — no API key required on this URL
    name = status.get("finalUserZipName") or f"{appid}.zip"
    with requests.get(status["download_link"], stream=True, timeout=(10, 600)) as r:
        r.raise_for_status()
        with open(name, "wb") as f:
            for chunk in r.iter_content(chunk_size=64 * 1024):
                f.write(chunk)

    return name


print("Saved", download("70"))
// Node 18+ — no dependencies
import { createWriteStream } from 'node:fs';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { setTimeout as sleep } from 'node:timers/promises';

const BASE = 'https://depotbox.lol';
const API_KEY = 'YOUR_KEY_HERE';

async function download(appid, { pollEvery = 2000, timeoutMs = 900_000 } = {}) {
  // 1. Start the job (only call that needs your key)
  const startRes = await fetch(`${BASE}/api/download`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY
    },
    body: JSON.stringify({ appid })
  });
  if (!startRes.ok) throw new Error(`${startRes.status}: ${await startRes.text()}`);

  const { token } = await startRes.json();
  console.log(`Job started: ${token}`);

  // 2. Poll until it is done
  const deadline = Date.now() + timeoutMs;
  let status;
  for (;;) {
    if (Date.now() > deadline) throw new Error('Gave up waiting for the package');

    status = await (await fetch(`${BASE}/api/status/${token}`)).json();

    if (status.status === 'completed' || status.status === 'completed_with_warnings') break;
    if (status.status === 'failed' || status.status === 'invalid_or_expired') {
      throw new Error(status.message || status.status);
    }

    console.log(`  ... ${status.message ?? 'working'}`);
    await sleep(pollEvery);
  }

  // 3. Fetch the file — no API key required on this URL
  const name = status.finalUserZipName ?? `${appid}.zip`;
  const fileRes = await fetch(status.download_link);
  if (!fileRes.ok) throw new Error(`${fileRes.status}: ${await fileRes.text()}`);

  await pipeline(Readable.fromWeb(fileRes.body), createWriteStream(name));
  return name;
}

console.log('Saved', await download('70'));
// Java 11+ — java.net.http only. JSON is read with tiny regex helpers
// so the example stays dependency-free; use Jackson or Gson in real code.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DepotBoxAsync {

    private static final String BASE    = "https://depotbox.lol";
    private static final String API_KEY = "YOUR_KEY_HERE";

    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .connectTimeout(Duration.ofSeconds(20))
            .build();

    private static String field(String json, String key) {
        Matcher m = Pattern.compile("\"" + key + "\"\\s*:\\s*\"([^\"]*)\"").matcher(json);
        return m.find() ? m.group(1) : null;
    }

    public static Path download(String appid) throws Exception {
        // 1. Start the job (only call that needs your key)
        HttpRequest start = HttpRequest.newBuilder()
                .uri(URI.create(BASE + "/api/download"))
                .header("X-API-Key", API_KEY)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString("{\"appid\":\"" + appid + "\"}"))
                .build();

        HttpResponse<String> startRes =
                CLIENT.send(start, HttpResponse.BodyHandlers.ofString());
        if (startRes.statusCode() >= 300) {
            throw new RuntimeException("HTTP " + startRes.statusCode() + ": " + startRes.body());
        }

        String token = field(startRes.body(), "token");
        System.out.println("Job started: " + token);

        // 2. Poll until it is done
        String body;
        long deadline = System.currentTimeMillis() + Duration.ofMinutes(15).toMillis();
        while (true) {
            if (System.currentTimeMillis() > deadline) {
                throw new RuntimeException("Gave up waiting for the package");
            }

            HttpRequest poll = HttpRequest.newBuilder()
                    .uri(URI.create(BASE + "/api/status/" + token))
                    .GET()
                    .build();
            body = CLIENT.send(poll, HttpResponse.BodyHandlers.ofString()).body();

            String state = field(body, "status");
            if ("completed".equals(state) || "completed_with_warnings".equals(state)) break;
            if ("failed".equals(state) || "invalid_or_expired".equals(state)) {
                throw new RuntimeException("Job " + state + ": " + field(body, "message"));
            }

            System.out.println("  ... " + field(body, "message"));
            Thread.sleep(2000);
        }

        // 3. Fetch the file — no API key required on this URL
        String link = field(body, "download_link");
        String name = field(body, "finalUserZipName");
        if (name == null) name = appid + ".zip";

        HttpRequest fetch = HttpRequest.newBuilder().uri(URI.create(link)).GET().build();
        HttpResponse<byte[]> fileRes =
                CLIENT.send(fetch, HttpResponse.BodyHandlers.ofByteArray());
        if (fileRes.statusCode() != 200) {
            throw new RuntimeException("HTTP " + fileRes.statusCode()
                    + ": " + new String(fileRes.body()));
        }

        Path out = Path.of(name);
        Files.write(out, fileRes.body());
        return out;
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Saved " + download("70").toAbsolutePath());
    }
}
// .NET 6+ — System.Text.Json
using System.Net.Http;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;

const string Base   = "https://depotbox.lol";
const string ApiKey = "YOUR_KEY_HERE";

static async Task<string> DownloadAsync(string appid)
{
    using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(15) };

    // 1. Start the job (only call that needs your key)
    using var startReq = new HttpRequestMessage(HttpMethod.Post, $"{Base}/api/download")
    {
        Content = new StringContent($"{{\"appid\":\"{appid}\"}}", Encoding.UTF8, "application/json")
    };
    startReq.Headers.Add("X-API-Key", ApiKey);

    using var startRes = await http.SendAsync(startReq);
    if (!startRes.IsSuccessStatusCode)
        throw new Exception($"{(int)startRes.StatusCode}: {await startRes.Content.ReadAsStringAsync()}");

    var token = (await startRes.Content.ReadFromJsonAsync<JsonElement>())
        .GetProperty("token").GetString();
    Console.WriteLine($"Job started: {token}");

    // 2. Poll until it is done
    JsonElement status;
    var deadline = DateTime.UtcNow.AddMinutes(15);
    while (true)
    {
        if (DateTime.UtcNow > deadline) throw new TimeoutException("Gave up waiting");

        status = await http.GetFromJsonAsync<JsonElement>($"{Base}/api/status/{token}");
        var state = status.GetProperty("status").GetString();

        if (state is "completed" or "completed_with_warnings") break;
        if (state is "failed" or "invalid_or_expired")
            throw new Exception($"Job {state}");

        Console.WriteLine($"  ... {status.GetProperty("message").GetString()}");
        await Task.Delay(2000);
    }

    // 3. Fetch the file — no API key required on this URL
    var link = status.GetProperty("download_link").GetString()!;
    var name = status.TryGetProperty("finalUserZipName", out var n) && n.ValueKind == JsonValueKind.String
        ? n.GetString()! : $"{appid}.zip";

    using var fileRes = await http.GetAsync(link, HttpCompletionOption.ResponseHeadersRead);
    fileRes.EnsureSuccessStatusCode();

    await using var file = File.Create(name);
    await fileRes.Content.CopyToAsync(file);
    return name;
}

Console.WriteLine($"Saved {await DownloadAsync("70")}");
#!/usr/bin/env bash
# Needs: curl, jq
set -euo pipefail

BASE="https://depotbox.lol"
API_KEY="YOUR_KEY_HERE"
APPID="${1:-70}"

# 1. Start the job
TOKEN=$(curl -sS -X POST "$BASE/api/download" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -d "{\"appid\":\"$APPID\"}" | jq -r '.token')

echo "Job started: $TOKEN"

# 2. Poll until done
while :; do
  STATUS_JSON=$(curl -sS "$BASE/api/status/$TOKEN")
  STATE=$(echo "$STATUS_JSON" | jq -r '.status')

  case "$STATE" in
    completed|completed_with_warnings) break ;;
    failed|invalid_or_expired)
      echo "Failed: $(echo "$STATUS_JSON" | jq -r '.message')" >&2
      exit 1 ;;
  esac

  echo "  ... $(echo "$STATUS_JSON" | jq -r '.message')"
  sleep 2
done

# 3. Fetch the file (no key needed on this URL)
LINK=$(echo "$STATUS_JSON" | jq -r '.download_link')
NAME=$(echo "$STATUS_JSON" | jq -r '.finalUserZipName // "'"$APPID"'.zip"')

curl -sSL --fail "$LINK" -o "$NAME"
echo "Saved $NAME"

Lua Generation — the .lua file on its own

These endpoints return only the .lua file for an AppID — no .manifest files, no ZIP wrapper. The response body is the Lua script itself, so you can write it straight to disk or read it as text. Authentication, rate limits and usage logging are identical to the manifest endpoints.

The shapes mirror the download endpoints exactly: direct (/api/direct-lua) for one-shot use, and async (/api/lua → poll → /api/lua/:token) when you want progress.

GET POST /api/direct-lua browser-friendly returns a file

One request, one .lua file, named <appid>.lua. The AppID may travel as a query parameter (GET) or in a JSON body (POST) — both are handled by the same code path.

Parameters:

ParameterTypeRequiredDescription
appidstringYesSteam AppID. Accepted in the query string or the JSON body.

Paste this into your browser's address bar:

https://depotbox.lol/api/direct-lua?appid=3641000&api_key=YOUR_KEY_HERE
# GET — everything in the URL
curl "https://depotbox.lol/api/direct-lua?appid=3641000" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  --fail -o "3641000.lua"

# POST — AppID in a JSON body
curl -X POST "https://depotbox.lol/api/direct-lua" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appid": "3641000" }' \
  --fail -o "3641000.lua"

# Print it to the terminal instead of saving it
curl -sS "https://depotbox.lol/api/direct-lua?appid=3641000" \
  -H "X-API-Key: YOUR_KEY_HERE" --fail
# Save to a file
Invoke-WebRequest -Uri "https://depotbox.lol/api/direct-lua?appid=3641000" `
    -Headers @{ "X-API-Key" = "YOUR_KEY_HERE" } `
    -OutFile "3641000.lua"

# Or keep the script in a variable
$lua = Invoke-RestMethod -Uri "https://depotbox.lol/api/direct-lua?appid=3641000" `
    -Headers @{ "X-API-Key" = "YOUR_KEY_HERE" }
Write-Host $lua
import requests

BASE = "https://depotbox.lol"
HEADERS = {"X-API-Key": "YOUR_KEY_HERE"}


def get_lua(appid: str) -> str:
    """Return the .lua file contents as a string."""
    r = requests.get(
        f"{BASE}/api/direct-lua",
        params={"appid": appid},
        headers=HEADERS,
        timeout=(10, 300),
    )
    if r.status_code != 200:
        raise RuntimeError(f"{r.status_code}: {r.text[:300]}")
    return r.text


lua = get_lua("3641000")

# Use it in memory...
print(lua[:200])

# ...or write it to disk
with open("3641000.lua", "w", encoding="utf-8") as f:
    f.write(lua)
import { writeFile } from 'node:fs/promises';

const BASE = 'https://depotbox.lol';
const API_KEY = 'YOUR_KEY_HERE';

async function getLua(appid) {
  const res = await fetch(`${BASE}/api/direct-lua?appid=${appid}`, {
    headers: { 'X-API-Key': API_KEY }
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.text();
}

const lua = await getLua('3641000');
console.log(lua.slice(0, 200));

await writeFile('3641000.lua', lua, 'utf8');
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;

public class DepotBoxLua {

    public static String getLua(String appid) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create("https://depotbox.lol/api/direct-lua?appid=" + appid))
                .header("X-API-Key", "YOUR_KEY_HERE")
                .GET()
                .build();

        HttpResponse<String> res =
                client.send(req, HttpResponse.BodyHandlers.ofString());

        if (res.statusCode() != 200) {
            throw new RuntimeException("HTTP " + res.statusCode() + ": " + res.body());
        }
        return res.body();
    }

    public static void main(String[] args) throws Exception {
        String lua = getLua("3641000");
        Files.writeString(Path.of("3641000.lua"), lua);
        System.out.println("Saved 3641000.lua (" + lua.length() + " chars)");
    }
}
using System.Net.Http;

using var http = new HttpClient();
http.DefaultRequestHeaders.Add("X-API-Key", "YOUR_KEY_HERE");

var resp = await http.GetAsync("https://depotbox.lol/api/direct-lua?appid=3641000");
var body = await resp.Content.ReadAsStringAsync();

if (!resp.IsSuccessStatusCode)
    throw new Exception($"{(int)resp.StatusCode}: {body}");

await File.WriteAllTextAsync("3641000.lua", body);
Console.WriteLine($"Saved 3641000.lua ({body.Length} chars)");

Error Responses:

  • 400 — No appid was supplied in the query or the body.
  • 404 — No depot keys exist for that AppID, so no .lua could be generated.
  • 429 — Rate limit exceeded.
  • 500 — Server error during generation.

POST /api/lua

Async version: starts generation and returns a token immediately. Poll /api/status/:token exactly as in the async download flow, then follow the returned download_link — which points at /api/lua/:token rather than /api/download/:token.

Request Body:

ParameterTypeRequiredDescription
appidstringYesSteam AppID to generate a .lua file for.

Example Request:

curl -X POST "https://depotbox.lol/api/lua" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{ "appid": "3641000" }'

Example Response (202 Accepted):

{
  "status": "processing",
  "token": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "polling_url": "/api/status/a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "download_url_prefix": "/api/lua/"
}
Reuse your async code

The Python / Node / Java / C# examples in Async Download work here unchanged — swap /api/download for /api/lua in step 1. Steps 2 and 3 are identical, because download_link already carries the correct URL.

GET /api/lua/:token browser-friendly no key needed returns a file

Fetches the generated .lua once the status is completed. Returns the raw file, not JSON. Like the ZIP token URL, this needs no API key and expires after 30 minutes — safe to hand directly to a user or a browser.

Example Request:

curl -L "https://depotbox.lol/api/lua/a1b2c3d4-e5f6-7890-1234-567890abcdef" \
  --fail -o "3641000.lua"

Game List

GET /api/gamelist/games browser-friendly

Returns every AppID in the DepotBox catalog in a single response — no paging, no cursors, no parameters. One call gives you the whole list. total comes first so you can size things up before reading the array.

This endpoint is free — it does not count against your rate limit. Your API key is only used to confirm you're an API customer, so calling it costs you no quota and won't show up in your usage stats. Must be called on https://depotbox.lol.

The response is a few MB, so pull it on a schedule and keep a local copy rather than calling it per lookup.

Example Request:

curl "https://depotbox.lol/api/gamelist/games" \
-H "X-API-Key: YOUR_KEY_HERE" -o catalog.json

Or straight in a browser:

https://depotbox.lol/api/gamelist/games?api_key=YOUR_KEY_HERE

Example Response:

{
  "success": true,
  "total": 128470,
  "games": [
    { "appid": 70,      "name": "Half-Life" },
    { "appid": 489830,  "name": "The Elder Scrolls V: Skyrim Special Edition" },
    { "appid": 1091500, "name": "Cyberpunk 2077" },
    { "appid": 4053960, "name": "Lexispell" }
  ],
  "count": 128470
}

total is the catalog size, count is how many entries were actually written. They match on a complete response — if the body ever fails to parse as JSON, the dump was cut short and should be retried rather than used.

To stay in sync after the first pull, use the Catalog Webhooks below — they tell you what changed so you don't have to re-download the list.

Catalog Webhooks

Set these on your API dashboard (Edit on your key). Both are plain Discord webhook URLs — we POST a standard Discord embed payload to them, so any endpoint that speaks the Discord webhook format works.

WebhookFires when
Added Game WebhookA game is added to the DepotBox catalog for the first time.
Updated Game WebhookA game already in the catalog gets a new public build — includes the build ID change and every depot whose manifest ID moved.

Updated Game payload:

{
  "embeds": [
    {
      "title": "Lexispell — Game Update",
      "url": "https://store.steampowered.com/app/4053960",
      "color": 5793266,
      "fields": [
        { "name": "App ID",        "value": "`4053960`" },
        { "name": "🔨 Build ID",    "value": "`23561746` → `23714292`" },
        { "name": "📦 Manifest ID", "value": "Depot `4053961`: `8471...` → `2093...`" },
        { "name": "🔗 Links",       "value": "[Steam Store](...) • [SteamDB](...)" },
        { "name": "📅 Release",     "value": "29 May, 2026",            "inline": true },
        { "name": "👤 Dev",         "value": "MrEliptik",               "inline": true },
        { "name": "⭐ Reviews",     "value": "Positive (28 reviews)",   "inline": true }
      ],
      "image": { "url": "https://.../header.jpg" }
    }
  ]
}

Up to 10 embeds per message. The 🔨 Build ID field shows old → new when a previous build is known, otherwise just the current one. Long depot lists are truncated with an “…and N more depots” line.

Data Retrieval

POST /api/search-games

Searches the DepotBox database by name or AppID, with advanced filtering options.

Request Body:

ParameterTypeRequiredDescription
searchTermstringYesThe name or AppID to search for.
limitintegerNoMax results. Default: 25, Max: 100.
filter_dlcstringNoOptions: "only" or "exclude".
filter_protectionstringNoOptions: "require" or "exclude".
filter_availabilitybooleanNoIf true, only returns games with a confirmed manifest in the database.

Example Request:

curl -X POST https://depotbox.lol/api/search-games \
-H "Content-Type: application/json" -H "X-API-Key: YOUR_KEY_HERE" \
-d '{
  "searchTerm": "Cyberpunk",
  "limit": 1,
  "filter_dlc": "exclude",
  "filter_availability": true
}'

Example Response:

{
  "success": true,
  "games": [
    {
      "appid": 1091500,
      "name": "Cyberpunk 2077",
      "is_dlc": false,
      "drm_notice": null,
      "header_image_url": "https://.../header.jpg"
    }
  ]
}

GET /api/games/:appid browser-friendly

Retrieves detailed information for a specific AppID, including manifest availability and a list of all associated DLCs.

Example Request:

curl "https://depotbox.lol/api/games/489830" -H "X-API-Key: YOUR_KEY_HERE"

Or straight in a browser:

https://depotbox.lol/api/games/489830?api_key=YOUR_KEY_HERE

Example Response:

{
  "success": true,
  "data": {
    "appid": 489830,
    "name": "The Elder Scrolls V: Skyrim Special Edition",
    "is_dlc": false,
    "drm_notice": null,
    "header_image_url": "https://.../header.jpg",
    "availability": { "db1_primary": true },
    "dlcs": [
      {
        "appid": 1746860,
        "name": "Skyrim Anniversary Upgrade",
        "header_image_url": "https://.../header.jpg"
      }
    ]
  }
}

GET /api/manifests/:appid browser-friendly

Provides a list of all .manifest files available for a given AppID from all sources, without downloading them.

Example Request:

curl "https://depotbox.lol/api/manifests/70" -H "X-API-Key: YOUR_KEY_HERE"

Or straight in a browser:

https://depotbox.lol/api/manifests/70?api_key=YOUR_KEY_HERE

Example Response:

{
  "success": true,
  "appid": "70",
  "sources": {
    "db1_primary": {
      "source": "local",
      "manifests": [ "1_2667117727132184734.manifest", ... ],
      "count": 18
    }
  }
}

POST /api/check-dlc

Checks one or more AppIDs to determine if they are a DLC. You can send a single AppID or an array of up to 100 AppIDs.

Request Body:

ParameterTypeRequiredDescription
appidstringEither/OrA single AppID to check.
appidsarray of stringsEither/OrAn array of AppIDs to check (max 100).

Example Request:

curl -X POST https://depotbox.lol/api/check-dlc \
-H "Content-Type: application/json" -H "X-API-Key: YOUR_KEY_HERE" \
-d '{ "appids": ["1746860", "489830", "9999999"] }'

Example Response:

{
  "success": true,
  "results": [
    { "appid": "1746860", "is_dlc": true, "status": "ok" },
    { "appid": "489830", "is_dlc": false, "status": "ok" },
    { "appid": "9999999", "is_dlc": null, "status": "not_found" }
  ]
}

Availability Checks

GET /api/games/:appid/availability browser-friendly

Quickly checks whether a single AppID is in the DepotBox catalog. This is a lightweight alternative to fetching full game details.

Check before you download. One cheap call here saves you a slow /api/direct-download that ends in a 404.

Availability matches the catalog exactly: if a game appears in /api/gamelist/games, this returns true for it, and vice versa.

Example Request:

curl "https://depotbox.lol/api/games/70/availability" -H "X-API-Key: YOUR_KEY_HERE"

Or straight in a browser:

https://depotbox.lol/api/games/70/availability?api_key=YOUR_KEY_HERE

Example Response:

{
  "success": true,
  "appid": "70",
  "available": true,
  "sources": {
    "db1_primary": true
  }
}

POST /api/games/batch-availability

Checks the availability of up to 100 AppIDs in a single request. Ideal for bulk validation before initiating downloads.

Same catalog source as the single-AppID check above.

Request Body:

ParameterTypeRequiredDescription
appidsarray of stringsYesAn array of AppIDs to check (max 100).

Example Request:

curl -X POST https://depotbox.lol/api/games/batch-availability \
-H "Content-Type: application/json" -H "X-API-Key: YOUR_KEY_HERE" \
-d '{ "appids": ["70", "220", "489830"] }'

Example Response:

{
  "success": true,
  "results": [
    {
      "appid": "70",
      "available": true,
      "sources": { "db1_primary": true }
    },
    {
      "appid": "220",
      "available": false,
      "sources": { "db1_primary": false }
    }
  ],
  "total": 2
}

Game Fixes

GET /api/game-fixes

Lists game fixes (online / bypass / hypervisor). Upstream catalogs are fetched through DepotBox proxies — source filenames are rewritten to clean game-based names. Filter by tag: online, bypass, hypervisor (comma-separated). Requires an API key (same rate limits and scrape protection as other gen endpoints).

Query Parameters:

ParameterTypeRequiredDescription
tagstringNoOne or more of online, bypass, hypervisor. Default: all three.
qstringNoSearch by game name or AppID.

Example Request:

curl "https://depotbox.lol/api/game-fixes?tag=bypass,online" -H "X-API-Key: YOUR_KEY_HERE"

GET /api/game-fixes/download browser-friendly returns a file

Downloads a fix archive. Prefer id from the list response, or pass the clean filename / downloadName (e.g. 007_First_Light_bypass.zip). Upstream credentials never leave the server.

Query Parameters:

ParameterTypeRequiredDescription
idstringNo*Fix id from the list endpoint (preferred).
filestringNo*Clean download filename from the list endpoint (e.g. Game_Name_bypass.zip).

* One of id or file is required.

Example Request:

curl -L "https://depotbox.lol/api/game-fixes/download?file=007_First_Light_bypass.zip" \
  -H "X-API-Key: YOUR_KEY_HERE" --fail -o "007_First_Light_bypass.zip"

Or straight in a browser:

https://depotbox.lol/api/game-fixes/download?file=007_First_Light_bypass.zip&api_key=YOUR_KEY_HERE

POST /api/game-fixes/generate-token NEW

Generates a temporary download token for a specific fix. This token can be used to download the fix without including your API key in the request, making it safe to serve downloads directly to end users.

Token Lifetime: 15 minutes | Reusable: Yes, until expiration | Limit: Up to 100 active tokens per API key

Request Body (JSON or Query Parameters):

ParameterTypeRequiredDescription
idstringNo*Fix id from the list endpoint (preferred).
filestringNo*Clean download filename from the list endpoint (e.g. Game_Name_bypass.zip).

* One of id or file is required.

Example Request:

curl -X POST "https://depotbox.lol/api/game-fixes/generate-token" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY_HERE" \
  -d '{"file": "007_First_Light_bypass.zip"}'

Example Response:

{
  "success": true,
  "token": "abc123XYZ_secure_token_here_456",
  "downloadUrl": "https://depotbox.lol/api/game-fixes/download-with-token?token=abc123XYZ...",
  "fixId": "ryuu:007_First_Light_bypass.zip",
  "downloadName": "007_First_Light_bypass.zip",
  "expiresAt": 1729012345678,
  "expiresIn": 900000,
  "message": "Token generated successfully. Use this token to download the fix without an API key."
}

Use Case:

Instead of proxying downloads through your backend to hide your API key, generate a temporary token on your server and provide the downloadUrl directly to your users. The token is tied to a specific fix and expires after 15 minutes.

GET /api/game-fixes/download-with-token browser-friendly returns a file no-api-key

Downloads a fix using a temporary token. No API key required. This endpoint allows you to serve fix downloads directly to end users without exposing your API key.

Query Parameters:

ParameterTypeRequiredDescription
tokenstringYesThe temporary token obtained from /generate-token.

Example Request:

curl -L "https://depotbox.lol/api/game-fixes/download-with-token?token=abc123XYZ..." \
  --fail -o "007_First_Light_bypass.zip"

Or directly in a browser (no API key needed):

https://depotbox.lol/api/game-fixes/download-with-token?token=abc123XYZ_secure_token_here_456

Error Responses:

  • 400 Bad Request - Missing token parameter
  • 404 Not Found - Token not found or already consumed (if single-use)
  • 410 Gone - Token has expired (after 15 minutes)

Game Requests

POST /api/game-requests

Submits a missing game request on behalf of the user who owns the API key. Requests start as pending and can later become accepted or rejected.

Daily limit: each user can submit at most 20 game requests within any rolling 24-hour period. This limit is shared across both the website and the API. Once reached, further requests return 429 Too Many Requests until older requests fall outside the 24-hour window.

Request Body:

ParameterTypeRequiredDescription
appidstringYesThe Steam AppID to request. appId is also accepted.
gameNamestringNoOptional fallback name if Steam details cannot be loaded.

Example Request:

curl -X POST https://depotbox.lol/api/game-requests \
-H "Content-Type: application/json" -H "X-API-Key: YOUR_KEY_HERE" \
-d '{ "appid": "1234560" }'

Example Response (201 Created):

{
  "success": true,
  "requestId": 42,
  "appid": "1234560",
  "gameName": "Example Game",
  "status": "pending",
  "submittedBy": {
    "userId": 7,
    "source": "api"
  },
  "message": "Request submitted. Staff will review it as soon as possible."
}

Example Response (429 Too Many Requests):

{
  "success": false,
  "dailyLimitReached": true,
  "limit": 20,
  "error": "You have reached the daily limit of 20 game requests. Please try again later."
}

GET /api/game-requests

Lists the game requests submitted by the API key owner. Results are paginated and can be filtered by status.

Query Parameters:

ParameterTypeRequiredDescription
pageintegerNoPage number. Default: 1.
limitintegerNoResults per page. Default: 25, Max: 100.
statusstringNoFilter by pending, accepted, or rejected.

Example Request:

curl "https://depotbox.lol/api/game-requests?status=pending&page=1&limit=25" \
-H "X-API-Key: YOUR_KEY_HERE"

Example Response:

{
  "success": true,
  "pagination": { "page": 1, "limit": 25, "total": 1, "totalPages": 1, "hasPrev": false, "hasNext": false },
  "filters": { "status": "pending" },
  "requests": [
    {
      "id": 42,
      "appid": "1234560",
      "gameName": "Example Game",
      "headerImage": "https://.../header.jpg",
      "status": "pending",
      "rejectionReason": null,
      "resolvedAt": null,
      "createdAt": "2026-06-17T10:00:00.000Z",
      "updatedAt": "2026-06-17T10:00:00.000Z"
    }
  ]
}

Depot Donations

POST /api/depot-donations

Donates depot keys for a game on behalf of the user who owns the API key. Donations start as pending; staff validate every key against Steam and then either add it to the main depot key store (added) or reject it (rejected).

Daily limit: each user can submit at most 30 donations within any rolling 24-hour period, shared across the website and the API. Once reached, further donations return 429 Too Many Requests.

Key format: every depot key must be exactly 64 hexadecimal characters. A donation can carry up to 50 depots, and at least one of them must be a key we don't already have.

Bonus: when staff add your keys and that makes the AppID downloadable, every pending game request for it is accepted automatically and those users are notified.

Blocked donors: banned accounts and banned IP addresses cannot donate and receive 403 Forbidden with "banned": true.

Request Body:

ParameterTypeRequiredDescription
appidstringYesThe Steam AppID the depots belong to. appId is also accepted.
depotsarray | object | stringYesThe donated depots. Accepts an array of { "depotId", "depotKey" } objects, a { "731": "hex..." } map, or depotid:key lines. depotKeys and keys are also accepted.
gameNamestringNoOptional fallback name if Steam details cannot be loaded.

Example Request:

curl -X POST https://depotbox.lol/api/depot-donations \
-H "Content-Type: application/json" -H "X-API-Key: YOUR_KEY_HERE" \
-d '{
  "appid": "1234560",
  "depots": [
    { "depotId": "1234561", "depotKey": "0f1e2d3c4b5a69788796a5b4c3d2e1f00f1e2d3c4b5a69788796a5b4c3d2e1f0" },
    { "depotId": "1234562", "depotKey": "112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00" }
  ]
}'

Example Response (201 Created):

{
  "success": true,
  "donationId": 17,
  "appid": "1234560",
  "gameName": "Example Game",
  "depotCount": 2,
  "newDepotCount": 2,
  "depotIds": ["1234561", "1234562"],
  "status": "pending",
  "submittedBy": { "userId": 7, "source": "api" },
  "invalidDepots": [],
  "message": "Thanks! Your depot keys were submitted. Staff will test them before adding them."
}

Example Response (409 Conflict — nothing new):

{
  "success": false,
  "duplicate": true,
  "error": "We already have every depot key in this donation. Thanks anyway!"
}

GET /api/depot-donations

Lists the depot donations submitted by the API key owner, with the review and testing state of each one. Donated keys are never echoed back — only the depot IDs are returned.

Query Parameters:

ParameterTypeRequiredDescription
pageintegerNoPage number. Default: 1.
limitintegerNoResults per page. Default: 25, Max: 100.
statusstringNoFilter by pending, added, or rejected.

Example Request:

curl "https://depotbox.lol/api/depot-donations?status=pending&page=1&limit=25" \
-H "X-API-Key: YOUR_KEY_HERE"

Example Response:

{
  "success": true,
  "pagination": { "page": 1, "limit": 25, "total": 1, "totalPages": 1, "hasPrev": false, "hasNext": false },
  "filters": { "status": "pending" },
  "donations": [
    {
      "id": 17,
      "appid": "1234560",
      "gameName": "Example Game",
      "headerImage": "https://.../header.jpg",
      "depotIds": ["1234561", "1234562"],
      "depotCount": 2,
      "status": "pending",
      "testStatus": "untested",
      "validDepotCount": 0,
      "keysAdded": 0,
      "rejectionReason": null,
      "resolvedAt": null,
      "createdAt": "2026-06-17T10:00:00.000Z",
      "updatedAt": "2026-06-17T10:00:00.000Z"
    }
  ]
}

testStatus is untested until staff run the validation, then passed (every key valid), partial (some valid) or failed (none valid). When a donation is added, keysAdded tells you how many keys actually landed in the store — keys we already had are skipped.

Usage & Analytics

GET /api/usage/stats

Retrieves comprehensive usage statistics for your API key, including request counts over time, top AppIDs, and recent request history.

Example Request:

curl https://depotbox.lol/api/usage/stats -H "X-API-Key: YOUR_KEY_HERE"

Example Response:

{
  "success": true,
  "stats": {
    "allTime": 15420,
    "last24h": 342,
    "last7d": 2150,
    "last30d": 8930
  },
  "top_appids": [
    { "appid": "70", "request_count": 520 },
    { "appid": "220", "request_count": 310 }
  ],
  "recent_requests": [
    { "appid": "70", "download_date": "2025-08-21T10:00:00.000Z" }
  ]
}

Community Lists

GET /api/lists/browse

Allows you to browse all public depot lists created by the community, with support for pagination.

Example Request:

curl "https://depotbox.lol/api/lists/browse?page=1&limit=5" -H "X-API-Key: YOUR_KEY_HERE"

Example Response:

{
  "success": true,
  "pagination": { "currentPage": 1, "totalPages": 25, "totalLists": 125, "limit": 5 },
  "lists": [
    {
      "id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
      "name": "Classic Valve Shooters",
      "description": "A collection of the best FPS games by Valve.",
      "likes": 250,
      "download_count": 3105,
      "created_at": "2025-08-21T10:00:00.000Z",
      "creator_username": "GamerGod",
      "depot_count": 15
    }
  ]
}

GET /api/lists/:listId

Retrieves the complete details of a specific public list, including the full list of games it contains.

Example Request:

curl https://depotbox.lol/api/lists/a1b2c3d4-e5f6-7890-1234-567890abcdef \
-H "X-API-Key: YOUR_KEY_HERE"

Example Response:

{
  "success": true,
  "data": {
    "name": "Classic Valve Shooters", "likes": 250, "creator_username": "GamerGod",
    "thumbnail_url": "https://.../apps/70/header.jpg",
    "games": [
      {
        "appid": 70, "name": "Half-Life",
        "header_image_url": "https://.../apps/70/header.jpg", "is_dlc": false
      }
    ]
  }
}

General & Stats

GET /api/stats no key needed browser-friendly

Retrieves public, real-time statistics about the DepotBox service. This endpoint is public and does not require an API key — a good way to confirm you can reach the API at all before debugging your key.

Example Request:

curl "https://depotbox.lol/api/stats"

Or straight in a browser:

https://depotbox.lol/api/stats

Example Response (200 OK):

{
  "success": true,
  "data": {
    "tracked_games_db1": 45820,
    "total_downloads_last_24h": 12530,
    "api_requests_last_24h": 87432,
    "most_popular_depot_last_24h": {
      "appid": 1245620,
      "name": "ELDEN RING",
      "downloads": 542
    },
    "public_lists_count": 1245
  }
}

Errors & Status Codes

Every failure comes back as JSON with an error string, whatever the endpoint — including the ones that normally return a file. Always branch on the status code first.

{
  "error": "Forbidden: Invalid API Key."
}
StatusWhat it meansWhat to do
200 OK Success. For download endpoints the body is the file. Save the bytes.
202 Accepted An async job was queued. Read token and start polling /api/status/:token.
400 Bad Request Missing or malformed parameter — usually no appid, or more than the allowed number of AppIDs. Fix the request. Retrying unchanged will not help.
401 Unauthorized No API key was sent at all. Add the X-API-Key header or the ?api_key= parameter.
403 Forbidden Key is invalid, pending approval, rejected, suspended, expired after rotation, or your IP is not on the key's whitelist. The message says which. Check your Dashboard. Do not retry in a loop.
404 Not Found No manifest / depot keys for that AppID, or a download token that expired or was already consumed. Try a different AppID, or start a new job if the token is stale.
429 Too Many Requests Rate limit exceeded. The message includes how many seconds remain in the window. Back off and retry after the stated delay.
500 Server Error Something broke while building your package. Retry once after a short pause; if it persists, contact support with the AppID.

Common mistakes

  • Saving the body without checking the status. A 404 from /api/direct-download writes a few hundred bytes of JSON. If your "ZIP" won't open, run cat on it — it's probably an error message. Use curl --fail, or check r.status_code / res.ok in code.
  • A 30-second HTTP timeout. Direct downloads build the package while the connection is open. Allow 10–15 minutes, or switch to the async flow.
  • Calling the API from browser JavaScript. There are no CORS headers, so fetch() from another origin is blocked. Call it from your backend.
  • Reusing a download token. Token URLs expire after 30 minutes and the temporary files are cleaned up once fetched. Start a new job instead of retrying an old link.
  • Hammering the status endpoint. Polling does not cost rate limit, but 2–3 seconds between polls is plenty — tighter loops just add load without finishing sooner.

Checking your remaining quota

GET /api/usage/stats gives you request counts over time — see Usage & Analytics. If you are writing a client that self-throttles, read the seconds-until-reset out of the 429 message rather than guessing.

Discord Bot

Every active paid API key can run its own Discord bot directly from the Dashboard. Open an active key, click Discord Bot, paste your bot token, choose which commands to enable, and press Start. All commands count against this key's rate limit.

Setup

  1. Create an application and bot at the Discord Developer Portal and copy the bot token.
  2. In the dashboard, open the Discord Bot modal for your key and paste the token.
  3. Enable the commands you want, set a Custom Name (shown as the embed footer), and optionally restrict the bot to specific server IDs with the Guild Whitelist (leave empty to allow all servers).
  4. Optionally restrict where the bot works under Gen Channels: start the bot, pick one of its servers from the list, and tick the channels it may answer in. It works per server — a server is only restricted once one of its own channels is ticked, so servers with nothing ticked stay unrestricted.
  5. Optionally enable Auto-gen so members can post a bare AppID in a gen channel instead of using a slash command.
  6. Toggle Allow NSFW games as desired, then press Save Configuration and Start.
  7. Invite the bot to your server with the applications.commands scope.

SLASH /manifest <appid>

Generates the full manifest package and replies with the .zip file plus a game-info embed. Disabled automatically for NSFW games when NSFW is turned off.

SLASH /lua <appid>

Replies with only the .lua file(s) for the given AppID, plus a compact game-info embed. Disabled for NSFW games when NSFW is turned off.

SLASH /gameinfo <appid>

Shows a rich embed with AppID, type, store price, DLCs included, Denuvo status, NSFW flag, store links and the header image. Games with online/multiplayer features are flagged with an Online Features Detected notice pointing to online-fix.me. Refuses NSFW games when NSFW is turned off.

AUTO <appid> posted in a gen channel

With Auto-gen enabled, posting just a Steam AppID (or a store/SteamDB link) in one of that server's ticked gen channels makes the bot reply with the package, exactly as /manifest would — falling back to /lua if /manifest is disabled. Messages with any extra text are ignored, and an AppID that does not exist on Steam gets a ❌ reaction instead of a gen, so it never burns a request. Each auto-gen counts as one request against the key's rate limit, and the NSFW and whitelist rules are identical to the slash commands.

This needs the privileged Message Content Intent enabled for your bot in the Discord Developer Portal — without it Discord refuses the connection. Auto-gen only listens in channels you ticked for that specific server; a server with no ticked channels never triggers it.

Notes

  • The bot token is stored encrypted (AES-256-GCM) and never shown again after saving.
  • Each slash command consumes one request from the key's per-minute rate limit.
  • Bots are restored automatically when the server restarts if they were running.
  • Manifest packages that exceed Discord's upload limit are rejected with an error message.