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.
Pick an AppID
The number in a Steam store URL. store.steampowered.com/app/70/ → AppID 70.
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"
.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:
| Method | How | Best 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
?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).
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?
| Flow | Shape | Use 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.
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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | The Steam AppID to package. |
api_key | string | Yes* | * 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | The 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:
| Parameter | GET (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);
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.
Start
POST /api/download → returns a token instantly (202).
Poll
GET /api/status/:token every 2–3s until status is completed.
Fetch
GET the download_link from step 2. That's your ZIP.
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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | The 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appids | array of strings | Yes | Up to 50 AppIDs. |
mergeFolders | boolean | No | Flatten 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:
| Field | Type | Description |
|---|---|---|
status | string | processing, completed, completed_with_warnings, failed, or invalid_or_expired. |
message | string | Human-readable current step. |
logs | array | Progress log lines — handy for a live status view. |
download_link | string | null until finished, then the full URL to fetch. |
finalUserZipName | string | Suggested filename for the result. |
expiry_minutes | integer | How long the link stays alive (currently 30 minutes). |
failureReason | string | Set 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | Steam 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— Noappidwas supplied in the query or the body.404— No depot keys exist for that AppID, so no.luacould 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | Steam 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/"
}
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.
| Webhook | Fires when |
|---|---|
| Added Game Webhook | A game is added to the DepotBox catalog for the first time. |
| Updated Game Webhook | A 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
searchTerm | string | Yes | The name or AppID to search for. |
limit | integer | No | Max results. Default: 25, Max: 100. |
filter_dlc | string | No | Options: "only" or "exclude". |
filter_protection | string | No | Options: "require" or "exclude". |
filter_availability | boolean | No | If 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Either/Or | A single AppID to check. |
appids | array of strings | Either/Or | An 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appids | array of strings | Yes | An 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
tag | string | No | One or more of online, bypass, hypervisor. Default: all three. |
q | string | No | Search 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
id | string | No* | Fix id from the list endpoint (preferred). |
file | string | No* | 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):
| Parameter | Type | Required | Description |
|---|---|---|---|
id | string | No* | Fix id from the list endpoint (preferred). |
file | string | No* | 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
token | string | Yes | The 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 parameter404 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | The Steam AppID to request. appId is also accepted. |
gameName | string | No | Optional 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
page | integer | No | Page number. Default: 1. |
limit | integer | No | Results per page. Default: 25, Max: 100. |
status | string | No | Filter 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
appid | string | Yes | The Steam AppID the depots belong to. appId is also accepted. |
depots | array | object | string | Yes | The donated depots. Accepts an array of { "depotId", "depotKey" } objects, a { "731": "hex..." } map, or depotid:key lines. depotKeys and keys are also accepted. |
gameName | string | No | Optional 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:
| Parameter | Type | Required | Description |
|---|---|---|---|
page | integer | No | Page number. Default: 1. |
limit | integer | No | Results per page. Default: 25, Max: 100. |
status | string | No | Filter 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."
}
| Status | What it means | What 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
404from/api/direct-downloadwrites a few hundred bytes of JSON. If your "ZIP" won't open, runcaton it — it's probably an error message. Usecurl --fail, or checkr.status_code/res.okin 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
- Create an application and bot at the Discord Developer Portal and copy the bot token.
- In the dashboard, open the Discord Bot modal for your key and paste the token.
- 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).
- 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.
- Optionally enable Auto-gen so members can post a bare AppID in a gen channel instead of using a slash command.
- Toggle Allow NSFW games as desired, then press Save Configuration and Start.
- Invite the bot to your server with the
applications.commandsscope.
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.