The RustMapCDN API.

Upload maps, run map votes and publish the winner from your own scripts, bots and panels. Every map still gets a permanent link for levelurl.

Create a key OpenAPI spec

Start in a minute.

1Create a key. Open your organisation in the dashboard, choose API, then Create key. Copy it straight away: it is only shown once.
2Upload with one request. Send the map file as the body, and name it in the address.
3Use the link. The url in the reply goes straight into your server's levelurl.

curl -X POST "https://rustmapcdn.com/api/v1/maps?filename=procedural_4500.map" \
  -H "Authorization: Bearer $RMC_KEY" \
  --data-binary @procedural_4500.map

In a wipe script, pull the link out of the reply with jq:

LINK=$(curl -s -X POST "https://rustmapcdn.com/api/v1/maps?filename=wipe.map" \
  -H "Authorization: Bearer $RMC_KEY" \
  --data-binary @wipe.map | jq -r .url)
echo "levelurl is now $LINK"

Keys.

Send your key in the Authorization header of every request. A key can either upload and change maps, or only read them. It works while the person who made it is still an owner or admin of the organisation, and stops the moment it is revoked.

curl https://rustmapcdn.com/api/v1/org \
  -H "Authorization: Bearer rmc_your_key"

On Windows, type curl.exe in PowerShell, because curl on its own runs a different command there.

Endpoints.

Every path starts with https://rustmapcdn.com/api/v1. Requests and responses are JSON, apart from the map files themselves.

Method	Path	What it does
GET	/org	The key's organisation, its limits and how many uploads are left today.
GET	/maps	Every map, newest first. Filter with ?status=live,off,expired.
POST	/maps	Upload a map of up to 95 MB as the request body, with ?filename=, and optionally ?name= and ?active=false.
GET	/maps/{id}	One map.
PATCH	/maps/{id}	Rename a map or switch it on or off, with {"name": "…"} or {"active": true}.
POST	/uploads	Start uploading a map of up to 200 MB in pieces.
PUT	/uploads/{id}/parts/{n}	Send piece n, counting from 1, in order.
POST	/uploads/{id}/complete	Join the pieces into one map.
DELETE	/uploads/{id}	Cancel an unfinished upload.

Every map comes back like this. world_size and format_version are read from the file, and are empty for maps uploaded before September 2026.

{
  "id": "e6c1b0a2-5d1f-4c7e-9a3b-2f8d6e4c1a90",
  "name": "Wipe 14 candidate A",
  "url": "https://rustmapcdn.com/your-server/e6c1b0a2-5d1f-4c7e-9a3b-2f8d6e4c1a90.map",
  "status": "off",
  "active": false,
  "size": 38421504,
  "original_filename": "procedural_4500.map",
  "world_size": 4500,
  "format_version": 10,
  "created_at": "2026-09-19T17:04:00Z",
  "expires_at": "2026-12-18T17:04:00Z"
}

Run a map vote.

1Upload each candidate switched off, with ?active=false or --off. Each gets its link straight away, but the link stays dark until you publish it.
2Run the vote wherever your players are: a Discord poll, an in-game plugin or your website.
3Switch the winner on, and put its link in your server's levelurl before the wipe. The others stay off and expire on their own after 90 days.

curl -X PATCH https://rustmapcdn.com/api/v1/maps/e6c1b0a2-5d1f-4c7e-9a3b-2f8d6e4c1a90 \
  -H "Authorization: Bearer $RMC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"active": true}'

Maps over 95 MB.

Cloudflare limits a single request to 100 MB, so bigger maps, up to 200 MB, go up in pieces. Start the upload with the file's name and size, send each piece of part_size bytes in order, then complete it.

POST /api/v1/uploads          {"filename": "huge_6000.map", "size": 157286400}
                              → {"upload_id": "…", "part_size": 52428800, "parts": 3}
PUT  /api/v1/uploads/{id}/parts/1   (the first 52428800 bytes)
PUT  /api/v1/uploads/{id}/parts/2
PUT  /api/v1/uploads/{id}/parts/3   (whatever is left)
POST /api/v1/uploads/{id}/complete  → the new map

Errors and limits.

Errors come back with a status code and a JSON body you can show to people as it is:

{"error": {"code": "not_a_rust_map", "message": "This file is not a Rust map (unknown format version 80). …"}}

Status	Code	Meaning
400	invalid_request, not_a_map_file, empty_file	Something in the request is missing or the wrong type.
401	missing_key, invalid_key	No key was sent, or it was revoked.
403	missing_scope	The key can only read maps.
404	not_found	No such map or upload in this organisation.
411	length_required	Send a Content-Length header.
413	too_large, use_upload_in_pieces	Over 200 MB, or over 95 MB in one request.
422	not_a_rust_map	The file is not a Rust map, so nothing was kept.
429	rate_limited, upload_limit	Over a limit. Wait for the seconds in Retry-After.

120 requests a minute for each key.
20 uploads a day through the API for each organisation. Uploads from the dashboard count towards it.
200 MB for each map, which must be a real Rust .map file.
90 days online for each map, from the day it is uploaded.

Version 1 stays stable. Any breaking change will arrive as a new version, and this one will keep running. The full description is in theOpenAPI spec.