TENSURA ANARCHY

Developers

Getting a key

The API at https://tensura-anarchy.com/api is read only, and every request for data needs a key. Each key belongs to one soul and is made only in our Discord, so every key is tied to a Discord account and the soul linked to it.

  1. Link your soul. In game, type /discord link, then within 10 minutes /link CODE in #commands. You become a Player.
  2. Make the key. Type /apikey new in #commands. The World answers each member once every 30 seconds, so after /link wait half a minute. The answer only you can see holds the key: ta_ and 43 more characters. It is shown once and fades after 5 minutes, so copy it at once.
  3. Look after it. /apikey status tells until when it holds and how often it was used, today and in all; /apikey new replaces it (the old key stops at once), /apikey remove destroys it. In game, /api tells whether your soul holds a key and until when.

A key holds 90 days. A direct message reaches you 7 days before it expires and when it expires (if your DMs are open), and the World tells you at login. It ends sooner when the link between your soul and your account ends (/unlink in the Discord, /discord unlink in game, a new link, leaving the Discord), or when an op revokes it.

Keep the key to yourself. It opens your soul's own record. Send it only in the header and only over https, never in an address: an address with key= or token= in it is refused (400, even with a good key in the header), and that key should be replaced at once, since addresses end up in logs and histories.

Making a request

Every request is a GET (or HEAD) with the header Authorization: Bearer <key>. Each endpoint answers with one whole JSON document. There are no query parameters: any you add are ignored, except key= and token= (refused, see above); take what you need from the answer. The answers change once a minute. All claims together are about 2 KB, the records of every soul about 80 KB, your own record tens of KB for a soul with many skills (every description and the whole history are in it); ask with Accept-Encoding: gzip (or zstd) and they come compressed (the records to about 11 KB).

curl

curl -H "Authorization: Bearer ta_YOUR_KEY" https://tensura-anarchy.com/api/claims

Python

import json
import urllib.request

KEY = "ta_YOUR_KEY"
request = urllib.request.Request("https://tensura-anarchy.com/api/claims",
                                 headers={"Authorization": "Bearer " + KEY})
with urllib.request.urlopen(request) as answer:
    data = json.load(answer)
for claim in data["claims"]:
    names = " / ".join(skill["name"] for skill in claim["skills"])
    holder = claim["holder"] or ("an unnamed soul" if claim["taken"] else "open")
    print(names, "-", holder)

Python on Windows: if urlopen stops with certificate verify failed: certificate has expired, the site's certificate is fine. Windows may still keep an old copy of ISRG Root X2 that expired on 2025-09-15 among its intermediate certificates, and Python trusts that store. Delete that copy (certmgr.msc, Intermediate Certification Authorities: ISRG Root X2, issued by ISRG Root X1, expiring 2025-09-15), or pass context=ssl.create_default_context(cafile=certifi.where()) to urlopen (pip install certifi; requests does this on its own).

JavaScript

const KEY = "ta_YOUR_KEY";
const answer = await fetch("https://tensura-anarchy.com/api/me", {
  headers: { Authorization: "Bearer " + KEY },
});
const me = await answer.json();
if (!answer.ok) throw new Error(me.error);
console.log("Soul Energy:", me.vessel?.soulEnergy.current);

Java

HttpClient http = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("https://tensura-anarchy.com/api/me"))
    .header("Authorization", "Bearer " + key)
    .build();
HttpResponse<String> answer = http.send(request, HttpResponse.BodyHandlers.ofString());
String json = answer.body();   // read it with Gson, Jackson or any JSON library

GET /api

The API describes itself: your key's soul and expiry (you.name, you.keyExpires), every endpoint, a line for each part of the answers, the limits and a link to this page. Ask it when your tool starts, and you know at once whether the key works.

GET /api/claims

The one-of-a-kind Ultimates: each permits a single holder in the World, and while one is held no other soul may obtain it. The same list as the Claims page, every claim taken or open. Shortened here and indented; the real answer is a single line.

{
  "generated": 1794592830000,
  "total": 13,
  "taken": 2,
  "claims": [
    {
      "skills": [{"id": "foxablazeultimate:azathoth", "name": "Azathoth, God of the Void", "color": "#aa00aa"}],
      "taken": false,
      "holder": null
    },
    {
      "skills": [
        {"id": "foxablazeultimate:ciel", "name": "Manas, Ciel", "color": "#ff5555"},
        {"id": "foxablazeultimate:raphael", "name": "Raphael", "color": "#ff5555"}
      ],
      "taken": true,
      "holder": "Example_Soul",
      "profile": "0f8e6d2c-5b4a-4c3d-9e2f-1a2b3c4d5e6f"
    },
    {
      "skills": [{"id": "foxablazeultimate:veldora", "name": "Veldora", "color": "#55ffff"}],
      "taken": true,
      "holder": "Another_Soul"
    }
  ],
  "fresh": true
}
generated
When the World last reported, in epoch milliseconds: every minute while the server runs.
fresh
false when the World has not reported for 5 minutes (the server is down or restarting): then these are the last known claims.
total, taken
Claims in all, and how many of them are held.
claims[].skills[]
The skills of one claim: id, name and the in-game color (#rrggbb, may be missing). [Manas, Ciel] and [Raphael] share one claim.
claims[].taken
true while a soul holds the claim.
claims[].holder
The holder's account name, or null: open, or held by a soul the World does not name.
claims[].profile
Only for a holder with a public character sheet: its UUID, for https://tensura-anarchy.com/profile.html?u=<uuid>.

GET /api/leaderboard

Every soul the World has recorded, as the Records of the World show them, strongest first: EP both as the World counts it and as the soul's own vessel holds it, prestige, Soul Grade, souls, race, the place on every board, and whether the soul is in the World right now. Shortened here and indented; the real answer is a single line.

{
  "generated": 1794592860000,
  "count": 303,
  "onlineCount": 1,
  "players": [
    {
      "name": "Example_Soul", "ep": 4200000000, "baseEp": 1500000000,
      "prestige": 5, "prestigeMedal": "gold", "soulGrade": 120, "soulGradeTier": "Supreme",
      "souls": 812.4, "soulPoints": 812450,
      "race": "Demon Slime", "family": "Slime", "alignment": "MAJIN",
      "ranks": {"ep": 1, "baseEp": 2, "soulGrade": 3, "souls": 12},
      "profile": "0f8e6d2c-5b4a-4c3d-9e2f-1a2b3c4d5e6f", "online": true
    },
    {
      "name": "Another_Soul", "ep": 2000000000, "baseEp": 2000000000,
      "prestige": 3, "prestigeMedal": "iron", "soulGrade": 60, "soulGradeTier": "High",
      "souls": 1514.2, "soulPoints": 1514290,
      "race": "True Dragonoid", "family": "Dragonewt", "alignment": "DEFAULT",
      "ranks": {"ep": 2, "baseEp": 1, "soulGrade": 9, "souls": 4}, "online": false
    }
  ],
  "fresh": true
}
generated
When the records were last written, in epoch milliseconds: every minute.
fresh
false while the World is down or has not reported for 5 minutes: then every number is the one last saved for that soul. While the World runs, the souls in it carry their exact numbers of that minute; a soul that is away keeps the ones saved when it left.
count
How many souls the records hold.
onlineCount
How many of them are in the World right now (the souls with online true).
players[]
In the order of the EP board: the highest ep first, equal values by name.
players[].name
The account name.
players[].ep
EP as the World counts it and the status menu shows it (Modified on the Records page): max magicule and max aura with every bonus of skills, effects and items. Each half stops at the World's limit of 5 billion.
players[].baseEp
Base EP: the magicule and aura of the vessel itself, without any bonus (what kills, training and evolutions built). It can lie below ep (bonuses) or above it (a weakening, or a vessel past the limit).
players[].prestige, prestigeMedal
How often the soul has prestiged, and the medal that brings: stone (0), copper (1), iron (3), gold (5), diamond (10), mithril (20), orichalcum (30), magisteel (40), adamantite (50), hihiirokane (64).
players[].soulGrade, soulGradeTier
Soul Grade, and its tier as the status menu names it: No Grade, Low, Medium, High, Greater, Grand, Supreme.
players[].souls, soulPoints
The souls gathered, as the status menu shows them (one decimal), and the raw soul points behind them (1,000 to a soul).
players[].race, family, alignment
The race's name (empty before the first reincarnation), its family, and the alignment: DEFAULT, MAJIN, HOLY or CHAOS.
players[].ranks
The place on each board, ep, baseEp, soulGrade and souls, 1 for the first; equal values are ordered by name.
players[].profile
Only for a soul with a public character sheet: its UUID, for https://tensura-anarchy.com/profile.html?u=<uuid>.
players[].online
true while the soul is in the World and its list of souls (the tab list) shows it; it follows a login or a logout within about a second. A soul that hides its presence reads false the whole time, as it does in game, and so does a player whose client has Allow Server Listings turned off (Options, Chat Settings). While the World is down or restarting, every soul reads false. Should online and onlineCount ever be missing, the World has no report to give: read that as unknown, not as away.

GET /api/me

Your own soul, and only yours: the key decides whose record you get. Nothing in it is more than you can see in game. Shortened here and indented; every field is in the spec for AI agents.

{
  "generated": 1794592800000,
  "online": true,
  "seenAt": 1794592800000,
  "sheet": {"account": "Example_Soul", "raceName": "Human", "alignment": "DEFAULT", "ep": 2450000,
            "baseEp": 2100000, "soulGrade": 4, "prestige": 2, "titles": [], "skills": []},
  "vessel": {
    "soulEnergy": {"current": 812.0, "max": 1000.0},
    "prayerCooldownSeconds": 0,
    "odds": {"prestige": 2, "deathsSinceLastPrestige": 1, "multiplier": 0.8,
             "tierPercent": {"S": 0.62, "A": 4.1, "B": 9.5, "C": 25.3, "D": 28.2, "E": 32.28}},
    "engravings": {"engraved": ["foxablazeultimate:veldora"], "slots": 1},
    "raceChosenInAdvance": ""
  },
  "surge": {"report": "(the text /surge gives in game)", "state": "counting", "dueInMs": 2580000,
            "realmEligible": true, "strained": false},
  "ultimateClaims": {
    "minutesToday": 42, "minutesNeeded": 60, "todayCounts": false,
    "held": [{"id": "foxablazeultimate:veldora", "name": "Veldora", "feldwayAuthority": false}],
    "calamityLimit": false, "limitDays": 7.0, "daysWithoutAnHour": 0,
    "lastActiveDay": "2026-11-12", "freedFromDay": "2026-11-20", "freedFrom": 1795129200000
  },
  "bounty": {
    "onThisSoul": {"bronze": 1000000, "stellarGold": 1, "gold": 0, "multiplier": 1, "text": "1 Stellar Gold Coin",
                   "postedAt": 1794428045000, "hunters": 0},
    "ledger": []
  },
  "market": {"offers": [], "waitingCoins": 0, "waitingItems": 0},
  "calamity": {"is": false, "namedDay": null, "source": null},
  "settings": {"profile": "public", "toastsOff": false, "hiddenDeaths": [], "discordLinked": true,
               "resourcePack": "auto"},
  "key": {"expires": 1802368800000, "expiresDay": "2027-02-11"}
}
generated, online
When this record was written (every minute while the server runs), and whether the soul is in the World: online turns false the moment the soul leaves. If the World goes down with the soul inside, it keeps saying true: a generated more than two minutes old means the World is down.
seenAt
When sheet, vessel and surge were last written. They change only while the soul is in the World, so while it is away they stay as last seen; until the soul has been in the World with its key, they are null.
sheet
The character sheet as on the website, also when it is sealed: race, EP and base EP (as in /api/leaderboard), souls, Soul Grade, prestige, titles, naming, deaths, kills, deeds, every learned skill with its mastery and lock, and the history.
vessel
soulEnergy (current, max), prayerCooldownSeconds (counts down only in the World), odds of the next Unique as /odds shows them (tier chances in percent), the Ultimate engravings and their slots, and the starting race chosen in advance (empty when none).
surge
Your surge as /surge tells it (report) and in numbers: state active (location: X and Z as /surge gives them, with the dimension outside the overworld; kinds, endsAt, slain), announced (startsAt, location, kinds), pooling, counting (dueInMs: online time left, it runs only while you are in the World; realmEligible, strained), none (reason) or off.
ultimateClaims
As /activity: minutes in the World today (counted up to the hour that counts), the claims you hold, limitDays (7, a Calamity's 2), the days without an hour so far, and freedFrom: from that moment the World frees your claims while you stay away. Every active day moves it. Without a held claim only the first four fields.
bounty
onThisSoul: the reward on you (in bronze, the smallest coin, and as coins), when it was posted and how many hunters hold a contract on you; contract: your own as a hunter; ledger: the claimed bounties you were part of. No positions in it: the only place the API names is your own surge's.
market
Your open offers, and the coins (in bronze) and items waiting for you at the merchants.
calamity, settings, key
Whether you are a Calamity, since when and why (quest, ultimates or op); your /profile, /toasts, /hide, /discord and /resourcepack settings; until when your key holds.

Limits and caching

curl -i -H "Authorization: Bearer ta_YOUR_KEY" https://tensura-anarchy.com/api/claims
#   etag: "3f1c0a9d2b7e4c5a6d8e"
curl -i -H "Authorization: Bearer ta_YOUR_KEY" -H 'If-None-Match: "3f1c0a9d2b7e4c5a6d8e"' \
     https://tensura-anarchy.com/api/claims
#   HTTP/2 304

Errors

Every refusal is JSON as well: {"error": "...", "docs": "https://tensura-anarchy.com/dev.html"}.

400
The address held key= or token=, also as part of a longer name (?apikey=...). Refused: make a new key with /apikey new, the old one may sit in a log by now.
401
No key, a wrong one, or one that has expired or ended (replaced, removed, revoked, its link gone).
404
/api/me before the World has written your record (within a minute of making the key, while the server runs), or an endpoint that does not exist (paths are case-sensitive).
405
Anything but GET, HEAD and OPTIONS: the API never changes anything.
429
Too many requests: wait the seconds in Retry-After.
503
/api/claims when the World has not reported its claims yet, or /api/leaderboard when the records cannot be read for a moment: ask again in a minute.
502, 504
Rare: the API itself is restarting. These come from the web server, without JSON and without CORS headers (a browser tool sees a network error): ask again in a minute.

A browser that opens an API address without a key is brought to this page.

Tools in a browser

The API answers requests from any website (every origin), so a page or an extension on your own computer can use it. Before the first request a browser asks with OPTIONS whether it may. The answer allows the Authorization and If-None-Match headers, and any other header the browser would have to ask about makes the question fail (even Content-Type: application/json on a GET). It also lets the page read ETag, Retry-After and the X-RateLimit headers. Browsers ask without the key, so each question counts toward the keyless requests of an address (6 in a row, then one every 10 seconds); the browser remembers the answer for a while (Chrome for 2 hours).

A key written into a page that others can open is a key everyone can read: keep keys in tools only you use. If one leaks, /apikey new replaces it at once.

For AI agents

Everything on this page, packed for an AI agent: copy it into your agent's instructions. Your key is not in it; hand that to the agent separately.

TENSURA_ANARCHY_API agent-spec v4 (2026-11-16); human docs https://tensura-anarchy.com/dev.html
BASE https://tensura-anarchy.com/api | read-only | JSON, ASCII-escaped | no query params, no pagination: each endpoint returns its whole document (/api/claims ~2 KB; /api/leaderboard ~80 KB for ~300 souls, ~11 KB gzipped; /api/me tens of KB, 56 KB seen, no cap: every learned skill with its description and the whole history); Accept-Encoding gzip or zstd -> compressed
AUTH header "Authorization: Bearer KEY"; KEY ~ ^ta_[A-Za-z0-9_-]{43}$; a query containing key= or token= (also inside a longer name: apikey=, monkey=) -> 400 even with a valid header; a KEY sent in a URL must be treated as leaked
KEY only the human can create it: Discord guild of Tensura Anarchy, slash command /apikey new (meant for #commands; the answer is private in any channel); needs their Minecraft account linked (in game /discord link, then /link CODE in #commands) and the Player role; the bot answers each member once per 30 s (wait 30 s after /link); shown once, the answer deleted after 5 min; 1 per soul (= Minecraft account); /apikey new replaces (old KEY dead at once), /apikey remove, /apikey status; TTL 90 d; dies early on /unlink (Discord) or /discord unlink (game), relink, leaving the guild, op revoke; scope = that soul's /api/me + public data
METHODS GET HEAD OPTIONS; any other method -> 405 (JSON, counted per client IP)
RATE token buckets, every request costs 1 (304 and errors too): per KEY burst 10, +1 per 2 s (30/min), counts 404/503/304 too; per client IP without a valid KEY (refusals 400/401/405, the 302 to the docs, CORS preflights) burst 6, +1 per 10 s; all valid KEYs together 600/min (burst 120); over -> 429 + Retry-After seconds; valid-KEY answers carry X-RateLimit-Limit (= the burst, 10) and X-RateLimit-Remaining (tokens left now); a 429 carries Retry-After and X-RateLimit-Remaining 0 (no X-RateLimit-Limit)
FRESHNESS server rewrites data every 60 s; poll each endpoint <= 1/min; /api/claims, /api/leaderboard and /api/me send ETag + Last-Modified; If-None-Match: ETAG -> 304 no body; the ETag ignores the top-level generated, so 304 = nothing else changed (/api/claims: until a holder, a profile link or fresh changes; /api/leaderboard: while no soul's numbers change and nobody logs in or out; /api/me: while the soul is away and nothing in it changes (bounty, market, claim days, settings), online it changes every minute); Cache-Control /api, /api/claims and /api/leaderboard "private, max-age=30", /api/me and errors "no-store"
CORS Access-Control-Allow-Origin *; allowed request headers Authorization, If-None-Match; exposed response headers ETag, Retry-After, X-RateLimit-Limit, X-RateLimit-Remaining; a browser request may add no other non-safelisted header (e.g. Content-Type: application/json on a GET fails the preflight); preflight max-age 86400 (browsers cap it, Chrome at 2 h); 502/504 carry no CORS headers, so a browser sees a network error; never embed KEY in a page others can load
TLS Let's Encrypt ECDSA chain YE1 -> Root YE -> ISRG Root X2 -> ISRG Root X1, all valid; Python urllib on Windows may fail "certificate has expired" when the Windows intermediate store still caches the old ISRG Root X2 (expired 2025-09-15): use ssl.create_default_context(cafile=certifi.where()) or requests, or let the human delete that expired certificate (certmgr.msc)
ERRORS body {"error":string,"docs":url}; 400 KEY in URL; 401 missing/unknown/expired/ended KEY + WWW-Authenticate: Bearer realm="tensura-anarchy"; 404 unknown path (case-sensitive), or no readable /api/me record yet (<= 60 s after KEY creation while the server runs); 405 any other method; 429 rate (Retry-After); 503 /api/claims not reported yet or /api/leaderboard unreadable for a moment (Retry-After 60); GET without Authorization and with Accept text/html -> 302 /dev.html; 502/504 without JSON or CORS headers = the API service is restarting, retry in 60 s
DOWNTIME daily restart 00:00 Europe/Berlin, monthly world reset 1st 03:00 Europe/Berlin (characters carry over): meanwhile the API keeps serving the last data and generated stops; /api/claims fresh=false after 300 s; /api/leaderboard keeps a moving generated (rebuilt from saved files every minute) with fresh=false after 300 s and every online=false after 90 s; /api/me has no fresh flag: its online turns false at logout but stays true if the World goes down with the soul inside, so treat a generated older than 120 s as down
UNITS timestamps = epoch ms; durations carry their unit in the name (dueInMs, prayerCooldownSeconds, lifeMinutes, minutesToday); *Day = YYYY-MM-DD Europe/Berlin; money = bronze (smallest coin); soul = player character; World = game server

GET /api -> {name, docs, readOnly:true, auth, endpoints:{path:desc}, fields:{path:desc}, limits, you:{name, keyExpires:ms}}

GET /api/claims -> {generated:ms, total:int, taken:int, claims:Claim[], fresh:bool}  (public data, as https://tensura-anarchy.com/claims.html)
Claim {skills:{id:"ns:path", name, color?:"#rrggbb"}[], taken:bool, holder:string|null, profile?:uuid}
- claim = one one-of-a-kind Ultimate skill (Raphael + Ciel share one claim); while held, no other soul can obtain it
- fresh=false: no report for 300 s (server down), claims are the last known
- taken && holder==null: holder not named; profile only when the holder's sheet is public: https://tensura-anarchy.com/profile.html?u=UUID

GET /api/leaderboard -> {generated:ms, count:int, onlineCount?:int, players:Player[], fresh:bool}  (public data, as https://tensura-anarchy.com/leaderboard.html, plus online, which the website does not show)
Player {name, ep:int, baseEp:int, prestige:int, prestigeMedal:"stone"|"copper"|"iron"|"gold"|"diamond"|"mithril"|"orichalcum"|"magisteel"|"adamantite"|"hihiirokane", soulGrade:int, soulGradeTier:"No Grade"|"Low"|"Medium"|"High"|"Greater"|"Grand"|"Supreme", souls:number (1 decimal, as the status menu), soulPoints:int (1000 per soul), race:string (display name, "" before the first reincarnation), family:string, alignment:"DEFAULT"|"CHAOS"|"MAJIN"|"HOLY", ranks:{ep:int, baseEp:int, soulGrade:int, souls:int}, profile?:uuid, online?:bool}
- players sorted by ep desc, then name case-insensitive; ranks = 1-based place on each board, same tie order; medal thresholds by prestige 0 stone, 1 copper, 3 iron, 5 gold, 10 diamond, 20 mithril, 30 orichalcum, 40 magisteel, 50 adamantite, 64 hihiirokane
- ep = max magicule + max aura with every modifier (skills, effects, items), each half capped at 5e9 (= the status menu, "Modified" on the page); baseEp = the two attribute bases without modifiers, not capped: may be below or above ep
- fresh=false: no live report for 300 s; numbers = last saved per soul; online souls carry live values, away souls their values at logout
- online = in the World now AND listed in its tab list for a player without op; follows logins/logouts within ~1 s; false for a soul that hides its presence (skills that hide from the tab list, ops in vanish) and for clients with Allow Server Listings off; all false when the World has not reported for 90 s (down); online and onlineCount absent only when the World has no report at all (feature off): treat as unknown, not as offline

GET /api/me -> the KEY's own soul only; never more than the player sees in game
{generated:ms, online:bool, seenAt:ms|null, sheet:Sheet|null, vessel:Vessel|null, surge:Surge|null, ultimateClaims:UC|null, bounty:Bounty, market:Market, calamity:{is:bool, namedDay:Day|null, source:"quest"|"ultimates"|"op"|null}, settings:{profile:"none"|"private"|"public", toastsOff:bool, hiddenDeaths:string[] (names), discordLinked:bool, resourcePack:"auto"|"manual"}, key:{expires:ms, expiresDay:Day}}
- sheet, vessel, surge are written only while online; offline they are the snapshot at seenAt; null until the soul was online with a KEY; all other fields refresh every 60 s, online or not
- online = in the World (the KEY's own soul, hidden or not); false from its logout on; stays true if the World goes down with the soul inside
Sheet {generated:ms, uuid, account, name, givenName?, namedBy?, race?:"ns:path", raceName?, alignment:"DEFAULT"|"CHAOS"|"MAJIN"|"HOLY", ep:int, baseEp:int, soulPoints:int, soulGrade:int, soulGradeLevel:int, prestige:int, titles:("True Demon Lord"|"Demon Lord Seed"|"True Hero"|"Hero Egg")[], discordLinked:bool, deathsThisPrestige:int, playerKillsThisLife:int, distinctVictims:int, lifeMinutes:int, bounty?:string, deeds:{id, title, description}[], skills:Skill[], history:{t:ms, text}[]}
Skill {id:"ns:path", name, kind:"Ultimate"|"Unique"|"Extra"|"Intrinsic"|"Common"|"Resistance"|"Skill"|"Magic"|"Battlewill"|"Other", description, element?, color?:"#rrggbb", mastery:number, maxMastery:number, mastered:bool, toggled:bool, locked:bool}
Vessel {soulEnergy:{current:number, max:number}, prayerCooldownSeconds:number (counts down only while online), odds:{prestige:int, deathsSinceLastPrestige:int, multiplier:number, tierPercent:{S,A,B,C,D,E:number}}|null, engravings:{engraved:skillId[], slots:int}, raceChosenInAdvance:string ("" = none)}
Surge {report:string (= in-game /surge text), state:"active"|"announced"|"pooling"|"counting"|"none"|"off"} + active:{location:string, kinds:string, endsAt:ms, slain:int} | announced:{startsAt:ms, location:string, kinds:string} | counting:{dueInMs:int (online time only), realmEligible:bool, strained:bool} | none:{reason}; location = "X <x>, Z <z>" + " in <dimension>" outside the overworld (the soul's own surge, as /surge tells it)
UC {minutesToday:int (capped at minutesNeeded), minutesNeeded:int, todayCounts:bool, held:{id, name, feldwayAuthority:bool}[]} + if held non-empty {calamityLimit:bool, limitDays:number (7, Calamity 2), daysWithoutAnHour:int (capped at ceil(limitDays)), lastActiveDay:Day, freedFromDay?:Day, freedFrom?:ms}
- held claims are freed while the soul stays away from freedFrom on; a day with minutesToday >= minutesNeeded moves freedFrom later; UC null = feature off
Bounty {onThisSoul?:Coins+{postedAt:ms, hunters:int}, contract?:{target:string, acceptedAt:ms, reward?:Coins}, ledger:{at:ms, role:"hunter"|"prey", other:string, reward:int (bronze), ultimates:string[]}[]}; no positions in bounty (the only coordinates in the API: the soul's own surge location)
Coins {bronze:int, stellarGold:int, gold:int, multiplier:int, text:string}
Market {offers:{item:{name, id, count:int, rarity:"COMMON"|"UNCOMMON"|"RARE"|"EPIC", renamed:bool, enchantments:string[], durability?:int, maxDurability?:int}, price:int (bronze), seller:string (this soul's name), listedAt:ms, expiresAt:ms}[], waitingCoins:int (bronze), waitingItems:int}