OverTheWire APIoverthewire.org ↗
Access OverTheWire wargame listings, level goals, SSH connection details, community rules, and suggested progression order via a structured REST API.
What is the OverTheWire API?
The OverTheWire API exposes 9 endpoints covering every wargame available on overthewire.org, from the full categorized wargame list to per-level goal text and SSH connection parameters. get_level_info returns the goal description for any specific level by wargame name and level number, while get_ssh_connection_info gives you the hostname, port, and initial username needed to connect without visiting the site manually.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/1cdf4da6-8aaf-471c-b2d5-f9fb1d571fe7/get_wargames_list' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace overthewire-org-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""OverTheWire Wargames SDK — discover games, plan progression, inspect levels."""
from parse_apis.overthewire_wargames_api import OverTheWire, WargameNotFound
client = OverTheWire()
# Browse the full catalog of available wargames
catalog = client.wargames.catalog()
print(f"Online wargames: {len(catalog.online)}")
for game in catalog.online[:3]:
print(f" {game.name} ({game.short_name}) — {game.url}")
# Check the recommended learning progression
order = client.wargames.suggested_order()
print(f"\nSuggested order ({len(order.order)} steps): {order.order[0]}")
# Construct a wargame instance and explore its levels
bandit = client.wargame(name="bandit")
for level in bandit.levels.list(limit=3):
print(f" Level {level.level}: {level.goal[:80]}...")
# Get SSH connection details for a wargame
ssh = bandit.ssh()
print(f"\nConnect: ssh -p {ssh.port} {ssh.user}@{ssh.hostname}")
# Drill into a specific level by number
level_zero = bandit.levels.get(level_number=0)
print(f"\nBandit level {level_zero.level}: {level_zero.url}")
# Typed error handling — catch not-found on a bad wargame name
try:
client.wargame(name="nonexistent_game").ssh()
except WargameNotFound as exc:
print(f"\nWargame not found: {exc.wargame_name}")
# Fetch a Natas web-security level directly
natas = client.wargames.natas_level(level_number=0)
print(f"\nNatas level {natas.level}: {natas.goal}")
print("\nExercised: catalog / suggested_order / levels.list / levels.get / ssh / natas_level")
Get a categorized list of all available wargames grouped by status (Online, Offline, Released). Each entry includes the wargame display name, short name, and URL. Returns the full catalog in a single response.
No input parameters required.
{
"type": "object",
"fields": {
"Online": "array of wargame summary objects with name, short_name, and url",
"Offline": "array of wargame summary objects with name, short_name, and url",
"Released": "array of wargame summary objects with name, short_name, and url"
},
"sample": {
"data": {
"Online": [
{
"url": "https://overthewire.org/wargames/bandit",
"name": "Bandit",
"short_name": "bandit"
},
{
"url": "https://overthewire.org/wargames/natas",
"name": "Natas",
"short_name": "natas"
}
],
"Offline": [
{
"url": "https://overthewire.org/wargames/semtex",
"name": "Semtex",
"short_name": "semtex"
}
],
"Released": [
{
"url": "https://overthewire.org/wargames/hes2010",
"name": "HES2010",
"short_name": "hes2010"
},
{
"url": "https://overthewire.org/wargames/abraxas",
"name": "Abraxas",
"short_name": "abraxas"
}
]
},
"status": "success"
}
}About the OverTheWire API
Wargame Listings and Metadata
get_wargames_list returns all wargames grouped into three arrays — Online, Offline, and Released — each entry containing name, short_name, and url. To go deeper on any single game, get_wargame_info accepts a wargame_name string (e.g. 'bandit' or 'natas') and returns the SSH host, port, display title, and a full levels array with each level's title and URL.
Level Details
get_level_info accepts wargame_name and a zero-indexed level_number and returns the goal text scraped from that level's page along with its url. For Natas specifically — a web-exploitation track — get_natas_level_info is a focused shortcut that returns the same shape but always sets wargame to 'natas', with the goal field including credentials and the in-game URL for that level. To pull every level for a wargame at once, get_all_levels_for_wargame returns a levels array with level, goal, and url for each entry, plus a top-level count. Note that this endpoint fetches each level page individually, so response time scales with the number of levels in the chosen wargame.
Connection Info, Rules, and Progression
get_ssh_connection_info returns hostname, port, and user (typically the wargame name followed by 0) for any shell-based wargame. get_rules returns the full community rules text as a single rules string. get_wargame_suggested_order returns an order array of strings describing the recommended sequence for working through the wargames — useful for building onboarding flows or curricula. get_released_wargame_info covers wargames listed under the Released category, returning a description field with the full text from that wargame's page.
The OverTheWire API is a managed, monitored endpoint for overthewire.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when overthewire.org changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official overthewire.org API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a CLI tool that pulls SSH connection info from
get_ssh_connection_infoand opens a session automatically. - Generate a study guide by fetching all level goals for a wargame using
get_all_levels_for_wargame. - Display the suggested wargame progression from
get_wargame_suggested_orderin a learning-path dashboard. - Sync the current wargame catalog with
get_wargames_listto detect when new challenges go online or offline. - Populate a CTF reference app with Natas credentials and URLs using
get_natas_level_infofor each level. - Embed community rules from
get_rulesinto onboarding flows for security training platforms. - Compare level counts across wargames by aggregating the
countfield fromget_all_levels_for_wargamecalls.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does OverTheWire have an official developer API?+
What does `get_wargame_info` return compared to `get_ssh_connection_info`?+
get_wargame_info returns the full wargame metadata including title, SSH host, port, and the complete levels array with each level's title and URL. get_ssh_connection_info is a narrower endpoint that returns only hostname, port, and the initial user string — the three values needed to form an SSH command. Both accept wargame_name as input.Are player solutions, forum threads, or spoilers available through this API?+
Is level goal text always plain text, or can it contain code or commands?+
goal field is returned as a string extracted from the level page. Some levels include shell commands, file paths, or credential strings inline with the instructional text. The field is not further structured, so any parsing of commands or credentials is left to the caller.Does the API cover offline or released wargames the same way as online ones?+
get_wargames_list returns all three categories — Online, Offline, and Released — with name and URL for each. However, get_released_wargame_info only returns a description field for released wargames; it does not return a levels array or SSH connection details the way get_wargame_info does for online wargames. You can fork the API on Parse and revise to extend level parsing to released wargame pages if that structure exists.