Search one bounded window of an explicit Hive account's authority-indexed history. Default: newest 100 records. Optional custom_json_id filter is applied locally. Returns next_start for an explicit later call, even when no matches occur. No automatic pagination; this is not complete incoming-recipient history. Oversized results are refused whole.

Read a full signed Hive transaction by transaction ID. Preserve every operation and signature; decode custom JSON and count recognized gift-card items separately. Does not establish game processing or irreversibility. One read-only RPC.

Inspect one transaction using a full Hive read and the existing Splinterlands game-result lookup. Returns independent chain/game outcomes, decoded game JSON, and gift-card agreement where provable. A game record does not prove processing of every operation in a multi-operation transaction. At most two logical reads.

Optionally supply up to ten uniquely labelled comparisons, each with a complete lineup snapshot, to evaluate alternatives alongside the baseline in one offline call. Each result retains its own validity; any invalid result sets isError while valid alternatives remain available. Alternatives are independent, not sequential moves. Offline deterministic Land what-if for Grain/Wood/Stone/Iron worksites. Supply an ordered worker snapshot (UID, detail ID, level, base PP, element and bloodline), plot terrain and efficiency, Power Core, optional Runi and item boost fractions. Bare UIDs cannot be resolved offline. Known edition-19 abilities use the dated resource; other workers require explicit ability tuples or an empty array. Returns raw/capped Base, Boostable and Total PP, gross resource/hour, food/hour, cap losses, ability activation and validity checks. Five ordinary slots with Core/Energized; Runi alone powers four plus itself. No HTTP, signing, ownership or live staking validation. Supply exactly one of plot.efficiency or regional_power (staked_dec, current_required_dec including this plot, current_plot_required_dec). Regional mode also needs each worker’s raw land_dec_stake_needed before cap/discount; it replaces old plot demand with the estimated new demand and holds all other plots unchanged. Output reports per-worker/plot demand, regional efficiency and shortfall. Runi needs no plot DEC and runs at full efficiency. Neutral workers have zero terrain modifier; dual-element workers use the better modifier. Terrain eligibility is checked for all four resources. Castles/Keeps, SPS and Research are outside this current estimator. Public-client formula evidence is dated; use an agreeing land_lineup_snapshot baseline for live comparisons.

Gather an explicit player's current Grain/Wood/Stone/Iron plot and selected candidate cards for land_lineup_estimate. Supply exactly one numeric/display plot_id or deed_uid. Select up to ten card detail IDs or twenty UIDs; current workers are always included. At most ten logical GETs, including one bounded-memory full collection stream; no automatic pagination or per-card lookup loops. Fetches deed, worker/project/plot facts, regional DEC, Power Core availability, definitions and up to 200 owner deeds for verified candidate locations. At most 100 matching cards; a larger selection is refused. Returns an estimator-ready baseline only when identity and backend production checks agree, candidate eligibility caveats, verified locations where returned, and per-source freshness. Reads are not atomic. Missing, cooling-down or unsupported cards are not presented as ready to stake. No stake changes are performed; Land stake changes remain scoped per plot.

Get a public deed by numeric plot_id or a region-tract-plot display label, padded or unpadded (for example 001-02-001 or 1-2-1). A label uses an observed candidate ID and verifies the returned coordinates before returning a deed. Empty or mismatched label resolution is explicitly unverified, not proof that the location does not exist. Successful populated responses include plot_reference with numeric ID, padded label and deed UID. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Get the public land-deed record for one deed uid. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Return the per-region plot counts reported for one account; the tool name is historical, and the response contains region rows rather than individual land records. A successful response has {status, data}, where data is an array of {count, uid} rows and uid is the region identifier. data: null was observed for an unrecognised account; behaviour for a known account with no land was not captured. Query probes limit=2 and offset=5 returned bodies byte-identical to the no-query response, so those tried values had no effect.

Search public land deeds by player or place (tract_id or region_number); a bare search is refused. A successful limited response is {status, data}, where data is an object carrying deeds, worksite_details and staking_details arrays. The catalogue declares those arrays as arrays of objects, and declares deed_uid as a string ID on each row; use that common deed_uid to join the three arrays. The deeds rows carry the public land-deed fields declared for this route. The worksite_details and staking_details rows carry the fields declared for those arrays, including staking_details[].total_work_per_hour, the per-deed total that a caller would rank deeds by; the response also carries a separate per-hour rate, worksite_details[].work_per_hour_per_one_pp, and this server does not relate the two; what it counts is not stated by the response and is not claimed here. total_work_per_hour is a JSON number, not a string, and this server returns it unchanged; it does not convert, round, rank, sort, sum or compare it, and a change in that wire type would be reported as a malformed response rather than converted silently. A zero total_work_per_hour was observed on deeds whose is_powered value was false, on one page of one account on one day (library/observations/land-deeds-search-details-2026-09-07.md); that observation does not establish that zero proves a deed is unpowered, what the figure counts beyond the field name, or what any unobserved value means. An empty result is a successful upstream answer, not an error, and establishes only that this response carried no rows; it does not establish that an account, place or deed does not exist, that no other matches exist, or that the response is complete. The limited form of this search has object-shaped data rather than an array, so this server's 100-row bound does not apply to that response. The only server result bound that applies to that response is the 256 KB serialized-result limit, and that limit is all-or-nothing. An oversized limited response returns status alone with the deeds, worksite_details and staking_details arrays dropped; the text says "This single record is too large to return within the 256 KB result limit." Request a smaller limit; retrying the same call will not return partial data. Paging probes recorded for this route were offset=0, offset=5, limit=10000, three calls omitting all parameters, and orderBy=desc: offset=0 returned zero rows; offset=5 returned the first four rows of the omitted-offset response; limit=10000 returned 10000 rows; the three omitted-parameter calls returned zero bytes; and orderBy=desc returned an empty data array. No total or has-more field was observed. No offset value tried reached later rows than the omitted-offset response; narrow the player, tract_id or region_number request instead. The observed ordered probe with orderBy=desc returned an empty array (measured 2026-09-06), and this server's contract currently accepts that response. A non-empty ordered response would be reported as malformed rather than returned. Because the observed ordered response was empty, no row bound or truncation is described for that form. Paging probes recorded for this route were offset=0, offset=5, limit=10000, three calls omitting all parameters, and orderBy=desc: offset=0 returned zero rows; offset=5 returned the first four rows of the omitted-offset response; limit=10000 returned 10000 rows; the three omitted-parameter calls returned zero bytes; and orderBy=desc returned an empty data array. No total or has-more field was observed. No offset value tried reached later rows than the omitted-offset response; narrow the player, tract_id or region_number request instead. This server makes one logical upstream request and reports what that request returned; it does not claim to analyse, rank, sort, sum or compare the returned deeds or detail rows.

Get the land project record the upstream reports as active for one deed uid. A deed with no active project is a successful answer with no record, not a failure. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the land project records the upstream returns for one deed uid. The recorded history probes were a bare request, offset=1, limit=2, and limit=2&offset=2: limit=2 narrowed from the start, while offset=1 and offset=2 did not reach later rows in those requests. This answer is additionally bounded to at most 100 rows and 256 KB by this server; if it is cut for that reason, the response reports that local bound. The project-count tool returns the count the upstream reports for this deed; whether that count covers exactly the records this tool would return has not been verified. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Get the count of land project records the upstream reports for one deed uid. This is one call and returns the upstream's count only, not the records. Whether that count covers exactly the records the history tool returns has not been verified. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the work requirement rows the upstream reports for one deed uid. Some deeds return no rows at all. A row's projected hours and projected end are the upstream's own values, and they can be far in the future: this repository observed rows carrying a projected end roughly five thousand years ahead. This server does not interpret those values and does not treat them as a schedule. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the 150 region count rows returned by GET /land/regions/counts. The unscoped call returns {status: "success", data: []}, an empty list. When a player is named, the response still carries all 150 regions rather than only that player's regions. Each row contains region.uid, region.name, region.region_number, for_sale, owned, listed, min_price and dec_stake. owned and dec_stake are the named player's fields. An unknown name returned the 150-row shape with owned and dec_stake zero; behaviour for a known account with no holdings was not captured.

List the tract count rows returned by GET /land/tracts/counts. The unscoped call returns {status: "success", data: []}, an empty list. A captured named-player response returned 36 rows, one per (region, tract_number) combination for which the account holds a deed. Each row contains region.uid, region.name, region.region_number, tract_number, owned and listed; all six row fields were present and non-null in every captured row. Whether any field is player-wide or player-scoped beyond this captured row shape is unmeasured, so this description makes no further absence claim.

Get the two land volume figures the upstream returns for GET /land/volume: a sum and a count. This route takes no parameters. Both figures are the upstream's own values. They were observed to change between two captures about an hour apart, and to decrease, so this server does not present them as a cumulative total. When this server observed the route, both figures were returned as JSON strings rather than numbers; that was true of every observation so far, not a guarantee about every response. This server passes the response through unchanged and does not convert, round or combine the figures, and a change in that wire type would be reported as a malformed response rather than converted silently. What the two figures measure, and over what period, is not stated by the response and is not claimed here.

List the resource-holding rows the upstream returns for one account and one resource, as GET /land/resources/owned returns them. A successful response is {status, data}, where data is an array of rows carrying id, region_uid, player, amount, resource_symbol, created_date, last_updated_date, region_name and region_number. All numeric fields are JSON numbers, and this server returns them unchanged; it does not convert, round, total or compare them, and a change in their wire type would be reported as a malformed response rather than converted silently. The upstream matches resource case-sensitively against its exact symbol. This tool uppercases the resource argument before making the request, but it does not enforce an enum: the observed symbols are not an exhaustive set. An unrecognised symbol returns an empty array that this server cannot distinguish from an account owning none of that resource. A missing player or resource produced data:null at HTTP 200 upstream; data:null therefore indicates a missing parameter in that observation rather than an empty holding, and this tool refuses either missing parameter rather than return that response. An empty array is a successful answer and does not establish that the account exists or that the account owns no resource beyond the request's returned rows. This tool reports the rows the upstream returned and nothing else: it does not infer holdings for symbols or regions the response does not list.

Get the resource-tax record the upstream returns for one deed, as GET /land/resources/taxes/{deedUID} returns it. A successful response is {status, data}, where data is one object carrying taxes and capacity. taxes was null on all three real deeds measured; no populated taxes array was ever observed. A fabricated deed id returned taxes:[] and capacity:0, while each of the three real deed ids returned taxes:null and capacity:1000000, so those measured real and fabricated responses are distinguishable. capacity was 1000000 on all three real deeds measured. That is either a shared cap or a field that does not vary by deed; one probe cannot tell those apart, so this description does not call it the deed's capacity. The taxes and capacity values are returned unchanged; this server does not interpret, total or compare them, and a change in their wire type would be reported as a malformed response rather than converted silently. The required deedUID is a path segment, so omitting it reaches no handler and is reported as an upstream routing failure. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the resource-richlist rows the upstream returns for one region and one resource, as GET /land/resources/richlist returns them. A successful response is {status, data}, where data is an array of rows carrying player, amount, region_uid and resource_symbol. amount is a JSON number, and this server returns it unchanged; it does not convert, round, total or compare it, and a change in that wire type would be reported as a malformed response rather than converted silently. The upstream matches resource case-sensitively against its exact symbol. This tool uppercases resource before making the request, but it does not enforce an enum because the observed symbols are not a declared exhaustive set. An unrecognised resource or region was observed to return data:[], which this server cannot distinguish from a genuinely empty ranking. Both region and resource are required by the upstream, and this tool refuses either missing parameter before making the request. This route uses region, not region_uid; other routes in this server take region_uid, and carrying that parameter name across to this route produces HTTP 400. Paging probes supplied offset=0, offset=5, page=2, cursor=5 and start=5; each returned parsed data equal to the limit=5 baseline. limit=50 returned 50 rows whose first five matched that baseline in the same order, and no ceiling was found at the tested limits 5 and 50. No value tried for offset, page, cursor or start produced a later slice. This tool reports the rows the upstream returned and nothing else.

List the resource-leaderboard rows the upstream returns, as GET /land/resources/leaderboards returns them. A successful response is {status, data}, where data is an array of rows carrying rank, player, amount, amount2, resource_per_hour, guild, title_pre, data and id. The numeric fields are JSON numbers, and this server returns them unchanged; it does not convert, round, total or compare them, and a change in their wire type would be reported as a malformed response rather than converted silently. The nested data field is a JSON-encoded string, not an object; this server returns it exactly as received and does not parse it, and a change in that wire type would be reported as malformed rather than converted. The upstream matches resource case-sensitively against its exact symbol. This tool uppercases resource before making the request, but it does not enforce an enum because the observed symbols are not a declared exhaustive set. Omitting resource returned HTTP 400. Omitting region with no territory produced no HTTP response in two measurements and timed out; territory was observed to work standalone without region, so this tool refuses only when both region and territory are absent. That refusal is this server's safety choice based on the observed hang, not an upstream validation rule. Supplying player returned that player's row in addition to the normal top rows. Paging probes supplied offset=0, offset=5, page=2 and from=5; each returned parsed data equal to the limit=5 baseline. limit=50 returned 50 rows whose first five matched that baseline in the same order, and no ceiling was found at the tested limits 5 and 50. No value tried for offset, page or from produced a later slice. This tool reports the rows the upstream returned and nothing else.

List the harvestable resource rows the upstream returns for one account and one land region, as GET /land/resources/production/region/harvestable returns them. A successful response is {status, data}, where data is an array of rows carrying amount_claimable, grain_required_for_food, wood_required, stone_required, iron_required and token_symbol. All numeric fields are JSON numbers, and this server returns them unchanged; it does not convert, round, total or compare them, and a change in their wire type would be reported as a malformed response rather than converted silently. The upstream returned HTTP 400 with Invalid parameters passed when either player or region_uid was missing, and this tool requires both before making the request. A fake player or region_uid returned data:[], a successful empty answer. This tool reports the rows the upstream returned and nothing else.

List the resource-balance history rows the upstream returns for one account and optional dates, as GET /land/resources/balances/history/{player} returns them. The player is a path segment on this route, not a query parameter. A successful response is {status, data}, where data is an array of rows carrying id, region_number, player, amount, end_balance, operation_id, resource_id, trx_id, created_date, balance_history and counterparty. The numeric fields are JSON numbers, created_date is a timestamp string, balance_history is an array and counterparty is a string; this server returns these fields unchanged and does not convert, round, total or compare them. Both YYYY-MM-DD and full ISO-8601 timestamps were accepted for startDate and endDate and produced identical results for the same calendar range. A malformed date returned HTTP 500, while a far-past date range returned a successful empty array, so this tool does not describe malformed dates as empty or unfiltered results. An unknown player returned HTTP 200 with an empty array; an empty result therefore does not establish that the account exists or does not exist. The default response contained 100 newest rows. limit=1000 and limit=500 returned HTTP 400; limit=3 with offset=0 returned three rows; limit=3 with offset=1, offset=2 and offset=3 returned HTTP 200 with empty arrays. No offset value tried reached rows beyond the newest 100. This tool reports the rows returned by the upstream and nothing else.

Get the resource-balance history count the upstream reports for one account and optional dates, as GET /land/resources/balances/history/{player}/count returns it. The player is a path segment on this route, not a query parameter. A successful response is {status, data}, where data is an object carrying count, a JSON number returned unchanged; this server does not convert, round or derive it. The measured count was 721. In the paired list probes, the default returned 100 newest rows, limit=3&offset=0 returned three rows, limit=3&offset=1, limit=3&offset=2 and limit=3&offset=3 returned empty arrays, and limit=500 and limit=1000 returned HTTP 400; those tried list parameters did not expose rows beyond the 100-row default, leaving 621 rows present in the count but absent from those list responses. The count and the list do not contradict each other: the count reports more rows than those responses contain. Whether the count covers exactly what the list would return was not verified, so this tool does not assert that relationship. A far-past date range returned count 0, matching the list route's empty result for the same range, and a malformed date returned HTTP 500. An unknown player returned count 0; that response does not establish that the account exists or does not exist. This tool reports the count returned by the upstream and nothing else.

List the public land-title rows the upstream returns for one player, as GET /land/resources/titles?player= returns them. The player is a query parameter. A successful response is {status, data}, where data is an array of rows carrying title, player and created_date; title and player are strings and created_date is a timestamp string, and this server returns them unchanged. Omitting player returned HTTP 400. An unknown player returned HTTP 200 with data:[], an honest empty result. This route is well-behaved: a missing player is rejected with HTTP 400 and an unknown player gives an empty array. This tool reports the title rows returned by the upstream and nothing else.

List the public title-assignment rows the upstream returns for one title, as GET /land/resources/titles/assigned?title= returns them. The title is a query parameter. A successful response is {status, data}, where data is an array of rows carrying title, player, created_date, avatar_id, league and modern_league. The title, player and created_date fields are strings or a timestamp string, and avatar_id, league and modern_league are JSON numbers; this server returns them unchanged. Warden and warden both succeeded. WARDEN returned HTTP 500, the same response as a nonexistent title and as a missing title parameter. A 500 does not establish whether the title exists. This route is not generally case-insensitive: two casings were observed to work and one failed. This tool sends the argument's case exactly as supplied and does not normalise it, because normalising toward an untested form could turn a working call into a 500. This tool reports the rows returned by the upstream and nothing else.

List the reward-action rows the upstream returns for one deed uid, as GET /land/resources/rewardactions/{deedUID} returns them. A successful response is {status, data}, where data is an array of rows carrying id, plot_id, tract_id, region_uid, site_efficiency, region_number, land_worksite_id, land_project_id, resource_id, resource_symbol, working_pp, duration, deed_uid, claim_amount, grain_required, claim_amount_eaten, amount_received, tax_burnt, amount_taxed, trx_description, trx_id, block_num, created_date, last_updated_date and fragment_roll. The numeric fields are JSON numbers, and this server returns them unchanged; it does not convert, round, total or compare them, and a change in their wire type would be reported as a malformed response rather than converted silently. fragment_roll is a nested object; this server returns it unchanged and does not interpret its fields. The default response contained 100 rows. A nonzero offset was measured to return data:[] rather than advance the list: limit=3&offset=3 and limit=1&offset=1 both returned empty arrays for a deed with 313 recorded actions. This is not the repeating-offset failure measured on the deeds search; it is an empty-array failure, and no offset value tried reached rows beyond the first 100. Supplying a limit narrows the returned rows from the start, but this tool does not imply that pagination works. A fake deed uid and a real deed with no actions both returned data:[], so an empty array establishes neither that the deed exists nor that it has no reward actions. A trx_id appears in these rows; this tool reports the rows returned by the upstream and nothing else, and does not claim what any numeric figure means. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Get the reward-action count the upstream reports for one deed uid, as GET /land/resources/rewardactions/{deedUID}/count returns it. A successful response is {status, data}, where data is an object carrying count, a JSON number; this server returns it unchanged and does not convert, round or derive it. The measured count was 313 for a deed whose reward-actions list returned 100 rows by default; limit=3&offset=3 and limit=1&offset=1 both returned empty arrays, so roughly 213 counted actions were absent from those three list responses. The count and list do not contradict each other: the count reports more actions than those responses contain. Whether the count covers exactly what the list would return was not verified, so this tool does not assert equivalence. A fake deed uid returned count 0, while the list route returned data:[] for both that fake deed and a real deed with no actions; these responses do not establish what an empty deed count would be. This tool reports the count the upstream returned and nothing else, and does not claim what the count means beyond the measured response. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the resource-history rows the upstream returns for one transaction id, as GET /land/resources/history/{trx_id} returns them. A successful response is {status, data}, where data is an array of rows carrying id, region_number, player, amount, end_balance, operation_id, resource_id, trx_id, created_date, balance_history and counterparty. The numeric fields are JSON numbers, including signed amount values; balance_history is an array; this server returns these fields unchanged and does not convert, round, total or compare them. These rows are not the private history of the deed whose reward-action row supplied the input: in one captured transaction, both measured rows named the same player, that player was not the source deed's owner, and the rows carried no deed identifier, so nothing in the response ties them to that deed. This is a bounded observation from those two rows in that one transaction, not a claim about every transaction. This route must not be described as that deed's history. A fake transaction id returned data:[] rather than an error, so an empty array establishes neither that the id exists nor that the transaction has no rows. No measured route surfaces a trx_id except reward-action rows, so this tool is reachable only by chaining from one of those rows; otherwise a caller has no measured way to obtain its input. This tool reports the rows returned by the upstream and nothing else, and does not claim what any numeric figure means.

List the fragment-history rows the upstream returns for one transaction id, as GET /land/resources/fragment_history/{trx_id} returns them. A successful response is {status, data}, where data is an array of rows carrying id, reward_action_id, land_work_type_id, land_project_number, tract_number, region_number, deed_uid, fragment_type, fragment_found, fragment_chance, fragment_roll, trx_id, block_num, created_date, last_updated_date, labors_luck_uid, labors_luck_chance, labors_luck_roll, labors_luck_pool_pick and labors_luck_treasures_left. The numeric fields are JSON numbers and fragment_found is a boolean; this server returns them unchanged and does not convert, round, total or compare them. The nullable fields are returned as received; the response does not state what fragment_chance or fragment_roll measures, and this tool does not interpret them. These rows are not the private history of the deed whose reward-action row supplied the input: in one captured transaction, the two measured rows carried differing deed_uid values, neither matching the source deed, so that transaction id covered records for more than one deed. The rows carried no player field, so this observation makes no claim about players. This is a bounded observation from those two rows in that one transaction, not a claim about every transaction. This route must not be described as that deed's history. A fake transaction id returned data:[] rather than an error, so an empty array establishes neither that the id exists nor that the transaction has no fragment-history rows. No measured route surfaces a trx_id except reward-action rows, so this tool is reachable only by chaining from one of those rows; otherwise a caller has no measured way to obtain its input. This tool reports the rows returned by the upstream and nothing else.

Get the single DEC staking figure the upstream returns for one account, as GET /land/stake/dec/overall returns it. A successful response is {status, data}, where data is a bare JSON number rather than an object or an array; this server returns it exactly as received and does not convert, round, scale or combine it, and a change in that wire type would be reported as a malformed response rather than converted silently. What the number counts, and over what scope, is not stated by the response and is not claimed here. This route does not enforce its declared-required player parameter: a call that omits it was measured to answer HTTP 200 with the number zero, the same zero observed for an unscoped call; whether that equals a real account with nothing staked was not tested, so this tool refuses a call with no player rather than return a plausible zero that describes nobody. A name that matches no account was measured to answer with the same kind of figure as a real account, so an answer from this tool establishes neither that an account exists nor that it does not. A zero returned for a named account is a successful answer and is not reported as no result. The per-region tool lists this account's staking rows separately; this server does not add those rows up, does not compare their total with this figure, and does not derive either from the other.

List the per-region DEC staking rows the upstream reports for one account, as GET /land/stake/decstaked returns them. A successful response is {status, data}, where data is an array of rows carrying id, region_uid, player, amount, percent_claimable, last_trx, created_date and last_updated_date. Every numeric field on this route is a JSON number, and a change in that wire type would be reported as a malformed response rather than converted silently. Rows carry the account name as the upstream returns it. An empty array is a successful answer, and an unknown name and an unscoped call were observed to return an empty array; behaviour for a known account with no staked DEC was not captured, so an empty answer establishes neither that an account exists nor that it does not. This route does not enforce its declared-required player parameter — a call with no parameters at all was measured to return that same empty array — so this tool refuses a call with no player rather than return an unscoped empty answer as though it described somebody. What percent_claimable measures is not stated by the response and is not claimed here. This tool reports the rows the upstream returned and nothing else: it does not total the amounts, does not compare them with the account's overall figure, and makes no statement about regions the response does not list.

Get the DEC staking figures the upstream reports for one account and one land region, as GET /land/stake/dec/region returns them. A successful response is {status, data}. data is an object carrying uid, dec_stake_needed, dec_staked and dec_stake_in_use when the upstream has a record for the request, including a full object of zero figures when a valid region has no stake for the account; the upstream returned an empty array for incomplete requests, but this registered tool refuses those requests before making the call. All three figures are JSON numbers, and a change in that wire type would be reported as a malformed response rather than converted silently. Removing player changed a resolved object response to an empty array; no numeric comparison was made. What each figure counts is still not stated by the response and is not claimed here. Neither declared-required parameter is enforced: a call omitting region_uid, and a call with no parameters at all, were both measured to answer HTTP 200 with an empty array, so this tool refuses a call that does not supply both player and region_uid. Different region uids were measured to return different figures. This tool reports the record the upstream returned for the request it was given and nothing else: it does not add figures across regions and does not compare them with any other route's.

Get the pending EVP claim figure the upstream reports for one account, as GET /land/stake/evp/pending-claim returns it. A successful response is {status, data}, where data is an object carrying a single pending_claim_amount field, a JSON number returned exactly as received; this server does not convert, round or accumulate it, and a change in that wire type would be reported as a malformed response rather than converted silently. What EVP is, what makes an amount claimable, and over what period the figure accrues are not stated by the response and are not claimed here. A zero is a successful answer. This server has observed zero for both a real account and a name that matches no account, while the real account's pending amount was also zero; whether this route distinguishes those cases is untested, so no answer from this tool may be read as saying that an account exists or that it does not. A call with no parameters at all was measured to answer HTTP 200 with a figure, so this tool refuses a call with no player rather than return a figure that describes nobody. This tool reports the figure the upstream returned and nothing else: it does not accumulate it, compare it with any DEC figure, or treat it as a balance.

Read each worker’s Base Production, Base PP after cap, Terrain Boost, Boostable Production and Total Production in worker_view, alongside unchanged source cards and items. Display labels follow the public client; explicit unpowered rows display zero while missing values remain unknown. The cap preview allocates ordinary workers in ascending slot order, then adds Runi outside the cap; see splinterlands://land/rules/screen-fields for source and limits. List the cards and items staked to one land deed, as GET /land/stake/deeds/{deedUid}/assets returns them. A successful response has {status, data}, where data holds a cards array and an items array; a deed with nothing staked returns both arrays present and empty, which is a successful answer and not a failure. On this route the boost, production-point and work figures are JSON strings, not numbers, and this server returns them exactly as received: it does not convert, round, compare or combine them, and a change in that wire type would be reported as a malformed response rather than converted silently. The deed-details tool returns the equivalent deed-level figures as JSON numbers; the two routes disagree about wire type and this server does not reconcile them. Rows carry the staking account name as the upstream returns it. A deed uid the upstream rejects is answered with an HTTP error on this route and is reported as an upstream failure rather than as an empty result, so this tool and the deed-details tool do not behave alike on a bad deed uid. This tool adds only a same-response worker label view: it does not count free slots, does not infer whether a deed is powered, and makes no statement about cards the response does not list. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Includes plot_view with the public overview PRODUCTION / HR value (Total PP times efficiency, or unscaled with Runi; zero when explicitly unpowered), plus separately labelled reference PP and resource-output values. Missing inputs remain unknown; raw response and provenance are preserved. Get the staking summary the upstream reports for one land deed, as GET /land/stake/deed/details/{deedUid} returns it. A successful response has {status, data}, where data is one flat record of the deed's staking flags, worker counts, boosts and totals. A deed with nothing staked returns that record fully present, with its numeric fields zero and its boolean flags false, so an empty answer on this route is a populated record rather than an absent one. On this route the boost and total figures are JSON numbers; the deed-assets tool returns the equivalent per-card figures as JSON strings. The two routes disagree about wire type, this server returns each exactly as received, and a change in that wire type would be reported as a malformed response rather than converted silently. The record carries a manager string as returned by the upstream; its role is not stated. A deed uid the upstream does not recognise was measured to return a successful response holding no record rather than an error, so an answer holding no record establishes neither that the deed exists nor that it does not: this server cannot tell it apart from a deed that exists and has no staking record. The one deed with nothing staked that this repository observed returned the zeroed record described above rather than no record, which is a single observation and not a rule. The deed-assets tool answers a rejected deed uid with an upstream error instead, so the two tools do not behave alike on a bad deed uid. This tool reports only what the record states: it does not compute free slots, does not derive which cards are staked, and does not treat a total as evidence about any individual card. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

List the six liquidity-pool rows the upstream returns, as GET /land/liquidity/pools returns them. A successful response is {status, data}, where data is an array of pool objects. The wire types are intentionally mixed: resource_quantity, dec_quantity and total_shares are JSON strings, while resource_price and the resource and DEC volume fields are JSON numbers. This server returns every field exactly as received; it does not convert the string-valued decimals, and a wire-type change would be reported as a malformed response rather than converted silently. The six observed rows had ids 1, 34, 67, 68, 69 and 100 with symbols GRAIN, VOUCHER, WOOD, STONE, IRON and SPS. This tool reports the rows returned by the upstream and does not derive prices, volumes or shares.

Get one liquidity-pool object by id, as GET /land/liquidity/pools/{id} returns it. A real id returned a single object with a narrower field set than the list route, omitting the one-day and thirty-day volume fields. An unknown well-formed id returned HTTP 200 with data:null, while a malformed id returned HTTP 400; these are distinguishable upstream outcomes. The object fields retain the mixed wire types observed on the list route: resource_quantity, dec_quantity and total_shares are JSON strings, while prices are JSON numbers. This server returns the upstream response unchanged and does not turn data:null into an error or manufacture a pool object.

Get one liquidity-pool object by symbol, as GET /land/liquidity/poolsbysymbol/{symbol} returns it. All five tested casings GRAIN, grain, Grain, VOUCHER and voucher returned the correct matching pool; this records five observed working casings and is not a general rule about every possible input. An unknown symbol returned HTTP 200 with data:null. The object fields retain the mixed wire types observed on the list route: resource_quantity, dec_quantity and total_shares are JSON strings, while prices are JSON numbers. This server sends the symbol as supplied, returns the upstream response unchanged and does not manufacture a pool object.

List the liquidity-swap rows the upstream returns for one player, as GET /land/resources/liquidity/swaps/{player} returns them. A real account returned 682 rows spanning all six observed pool ids. The rows carry numeric ids, quantities and pool quantities, string player/token/transaction fields and timestamp strings; this server returns each row unchanged and does not interpret or total the figures. An unknown player returned HTTP 200 with data:[], a different empty shape from the data:null used by the two pool lookup routes. An empty array therefore establishes neither that the account exists nor that it has no swaps.

List the 12 real (token, liquidity_pool_id) reward-total pairs returned by GET /land/liquidity/allrewards. DEC appeared once for each of the six observed pools, and each pool's own resource token appeared once. reward_total and liquidity_pool_id are JSON numbers and token is a string. This tool returns the rows unchanged and does not derive totals or pool membership.

Get the best route in this liquidity family: a genuine linear, pool-specific quote from GET /land/liquidity/quote/{poolId}. resource_amount and dec_amount are optional inputs and the response carries both quoted amounts. The relationship was verified arithmetically from observed pairs: at the values tested, doubling dec_amount from 100 to 200 exactly doubled resource_amount from 12144.988 to 24289.976, and the relationship held at 1e14. This is an observed relationship at those tested values, not a formula this project has verified across the whole input range. Pool ids 1, 34 and 67 returned different quotes for the same amount. Zero and negative amounts clamp to 0/0, non-numeric amounts return HTTP 400, and an unknown well-formed pool returns 0/0. The one trap is that supplying both resource_amount and dec_amount silently lets resource_amount win, so a caller providing both receives an answer to only one of their questions. This tool reports the upstream quote unchanged.

List per-region resource rows from GET /land/liquidity/resources/{player}/{token}. This route validates properly: a garbage player, a garbage token and both garbage returned genuine empty arrays with no synthesised entry. token matching is case-sensitive. GRAIN, WOOD, STONE, IRON, RESEARCH and AURA were observed; the set is not declared exhaustive. Each row carries id, region_name, region_number, region_uid, player, amount, resource_symbol, created_date and last_updated_date, and this tool returns those fields unchanged.

Get one row per region from GET /land/liquidity/region/{player}, a pivot of six per-token calls to GET /land/liquidity/resources/{player}/{token}. Relative to that named per-token route, this gains plots_owned and a human-readable region name available from no other measured route, while losing each per-record id, created_date and last_updated_date. It is therefore a one-call regional summary that removes fan-out; choose the per-token route when those record metadata fields are needed. An unknown or case-mismatched player returns a genuine empty array. This tool returns the upstream rows unchanged.

Optional include_plot_references adds reported_stake_plot_reference with verified padded label, numeric ID and deed UID to returned cards using at most one account-scoped deed search (limit 200); the call then permits three logical GETs instead of two. Unresolved or conflicting references remain null with explicit status and separate freshness. This is not complete holdings discovery. Cooling cards have left their old plot; a retained reference is historical. The projected collection cache is reused when only this option changes, and plot references are read afresh. Joined metadata exposes normalized element and secondary_element, plus only the selected level’s land_abilities and land_abilities_status. Missing level entries are unknown, never an invented empty ability list; absent ability tables mean no Land abilities in that definition. Raw numeric land_dec_stake_needed is retained if present. The element filter matches either normalized element. For known edition-19 cards, land_lineup_estimate resolves its dated abilities itself; omit an explicit abilities override there. Other cards can use the returned ability tuples, subject to estimator-supported codes. Optional stake_start_date, stake_end_date and numeric stake_plot are retained when present. staking_status and staking_observed_at classify one capture as staked, unstaking, unstaked, pending or unknown; cached pages preserve that classification time. Missing dates are unknown, not unstaked. Local staked=yes selects active staking, staked=no selects explicitly unstaked cards (not cooling or pending), and staked=plot requires numeric stake_plot_id. Plot labels are not inferred from an unverified numeric reference. These filters make no extra request. Stream the projected collection returned by GET /cards/collection/{username}. The upstream response has exactly {player,cards[]} and no total, count, cursor, page token or other pagination field; no narrower query was available in the measured collection evidence. The route-size and memory measurements are recorded in library/observations/collection-streaming-memory-2026-09-08.md. The server never materialises the upstream body: it parses cards[] incrementally, skips unprojected fields, counts matching cards, and retains only the projected cards in the requested page, up to 100. Each emitted card contains uid, card_detail_id, edition, gold, foil, level, xp, bcx, collection_power and card_set. The source card object carried 56 fields; this projection keeps the ten core fields plus land_base_pp when present, and makes no byte-saving claim. In the upstream wire types, land_base_pp and last_buy_price are numeric-looking JSON strings, while bcx, xp, collection_power and level are real JSON numbers; land_base_pp is retained as its original decimal string and last_buy_price is not projected. A missing land_base_pp stays absent; an observed null stays null. Both mean unknown production and never pass a min_land_base_pp filter, including a zero threshold. Malformed or non-finite production strings are refused; the latter four fields are returned as numbers. Card definitions are joined by card_detail_id, adding name, color, secondary_color when present and sub_type. Color and subtype filters are case-insensitive exact matches; color matches either primary or secondary color. Unknown definitions retain the instance without invented fields, never match metadata filters, and are counted in definition_missing_count across the full scanned collection before filtering. The complete definition catalogue is fetched under the existing 2 MiB cap and projected into one 24-hour cache; only joined page fields are returned. This tool may use two logical GET requests (definitions plus collection). Definition failure stops before reading the collection. Definition refresh invalidates the joined page cache, and metadata freshness is separate. Local filters are color, sub_type, gold, edition, foil, card_set, min_level, min_collection_power and min_land_base_pp; cursor is a zero-based filtered-result offset and limit defaults to 100 with a maximum of 100. This server's heap-occupancy guard is 128 MiB: the highest observed production-path value was 90.71 MiB of unforced heapUsed; the occupancy backstop is wider because GC timing can vary, so it needs operational slack. Production normally has no --expose-gc, so heapUsed is high-water heap occupancy including uncollected garbage, not a retention bound. If global.gc is exposed, as it may be in a diagnostic/test process, the server calls it before sampling to reduce transient garbage. Retention was measured separately at about 9.4 MiB flat under forced GC and is verified by test, not at runtime. A separate 358 MiB RSS operational ceiling is based on the highest RSS observed across the measurement rounds: 286.4 MiB in the forced-GC diagnosis, higher than the 278.08 MiB RSS maximum of the final production-path runs. RSS is a separate process-occupancy backstop, not a retention bound, and includes memory outside the V8 heap and uncollected garbage. Neither runtime number bounds retention: both are occupancy guards at different scopes, while retention is verified by measurement, not enforced at runtime. Memory is sampled every 256 parsed cards, plus once at the end when needed; on the measured 51,799-card run that means at most 203 cadence samples, and a regression is detected within 256 parsed cards without a memory call on every card. The route uses a 90-second timeout chosen by this server behind the measured 41-second fetch; a timeout is attempted once and is not retried. The global 2 MB response cap is unchanged for every other route and is not raised for this exception. One successful page is cached for 60 seconds per username, retaining at most that page; cache reuse requires the same filter, cursor and limit request. A different page or filter is a cache miss, re-streams and re-parses the full collection, and replaces that username's cached page because the upstream has no pagination; the cached page re-streams after expiry. The fixture is deliberately trimmed to three cards with representative raw fields rather than the measured 155 MiB response; the fixture declares every concrete array index and is only a contract sample. No account name is embedded in this server source, and this server remains version 0.0.0 with no remote delivery path.

List the card-definition rows returned by GET /cards/get_details. The type query is a real upstream filter: type=Summoner returned 107 rows versus 1101 rows from the bare route. The bare upstream response measured about 1.17 MB, so this server refuses an unfiltered call before sending it because the response exceeds this server's 256 KB result bound and would otherwise be reduced to status alone with the data dropped. That refusal is this server's size-based choice from the measured response, not an upstream rule; provide type to make a filtered call. Each returned definition carries id, name, color, type, sub_type, rarity, drop_rate, per-level stats, abilities, editions, total_printed and distribution fields. The measured route carried no BCX, donor or account-attribution field. Successful filtered metadata responses are cached for 24 hours; provenance reports the route and the original fetch time. This tool reports the filtered rows returned and does not add per-instance ownership data.

Get the lore object returned by GET /cards/lore for one card_detail_id. The measured successful response was a bare object with numeric card_detail_id and string text. Omitting card_detail_id returned HTTP 200 with an empty body and no JSON, so this tool requires card_detail_id before making the request. The measured response carried no BCX, donor or account-attribution field. Successful lore responses are cached for 24 hours; provenance reports the route and the original fetch time. This tool returns the lore object unchanged and does not derive card attributes from its text.

List the skin rows returned by GET /cards/skins. The measured public response was a bare array of 74 objects, each carrying card_detail_id, skin, total, remaining, cost, set_cost and set; the captured body was 8,893 bytes. The measured response carried no BCX, donor or account-attribution field. Successful metadata responses are cached for 24 hours; provenance reports the route and the original fetch time. This tool returns the rows unchanged and does not calculate availability or prices.

List the pack metadata rows returned by GET /cards/pack_data_wax. The measured public response was a six-object bare array for ALPHA, BETA, ORB, UNTAMED, DICE and CHAOS, with symbol, template_id, max, minted and burned fields as JSON numbers. The measured response carried no BCX, donor or account-attribution field because it is WAX-bridge mint/burn metadata rather than per-card or per-owner data. Successful metadata responses are cached for 24 hours; provenance reports the route and the original fetch time. This tool returns the rows unchanged.

List the transfer records returned by GET /cards/history for one per-instance card UID. id is a card UID, not a card_detail_id: numeric ids silently returned [], while a real UID returned transfer records. A returned record carries card_id, transfer_date, transfer_type, transfer_tx, from_player, to_player, card_detail_id, xp, gold, edition, payment_amount, payment_currency and combined_cards. from_player and to_player are account-attribution fields for the transfer, not donor provenance. Donor and BCX were absent in the measured response. This route is a per-instance event lookup, not a card-definition lookup or an enumeration of history for a numeric card_detail_id. The result is limited by this server's 100-row and 256 KB bounds and is not cached as static metadata.

Look up per-instance card records through GET /cards/find. Supply ids as one comma-separated string of full per-instance card UIDs; real 2-ID and 3-ID requests returned exactly the requested UIDs in order. Repeated ids=, ids[]= and JSON-array encodings are not valid: repeated and bracketed parameters return an unable-to-parse error, while a JSON array is split as literal comma-separated text. A matched record carries player, uid, card_detail_id, xp, gold, edition, card_set, collection_power, market and rental fields, and the measured bcx and bcx_unbound fields. BCX is therefore promised for this per-instance route only; it is not a claim about definition routes. player is current-owner attribution, not donor provenance, and donor was absent in the measured record. This result is bounded by this server's 100-row and 256 KB limits and is not cached as static metadata.

List the full item-type catalogue returned by GET /players/item_details. The measured public response contained 320 items and was about 134 KB, with id, name, type, nullable sub_type, data, transferable, consumable, inventory, nullable print_limit, total_printed, nullable image_filename, nullable icon_filename, nullable description, nullable rarity and stake_type_id. The id parameter is inert: the no-id response and id=1 response were byte-identical, so this tool does not advertise id as an item lookup filter. The measured response carried no BCX, donor or account-attribution field. Successful metadata responses are cached for 24 hours; provenance reports the route and the original fetch time. This server applies its general 100-row and 256 KB result bounds to the returned array; it does not claim that the bounded response is the full upstream catalogue.

Resolve one player's legacy profile image link, which may be RUNI artwork and is not the avatar-builder character. Reads the official avatar endpoint once logically, inspects its HTTP 302 Location without following it, and returns avatar_url, image_url and redirect_status. Only HTTPS Splinterlands-domain image destinations are accepted. No image bytes are downloaded; the current image URL may change. A returned avatar does not prove the account exists. No credentials or game writes.

Read the saved custom avatar-builder settings from the official player_avatar endpoint. Returns numeric level separately as data alongside appearance selections and badges. Set render=true to compose the official artwork layers into a PNG; metadata-only calls download no images. Rendered art excludes level text, badges and exemplar level frame/gem overlays. Level text must not be automatically added to artwork; any client level label is separate. Use this for the custom character, not the legacy RUNI/profile image redirect. No credentials or game writes.

Return one account's profile from GET /players/details. This route is ABSENT from the main host's published declaration and was found by probing; it answered publicly with no token, and its selector is name, not username. The captured response was about 4.7 KB and carried the account name, join date, ranked figures, collection power, league, a public guild record, a player_uuid and a season pass flag. Ranked figures appear per format: the wild figures are unprefixed, with modern_, survival_ and foundation_ fields alongside. player_avatar is a JSON-encoded string inside the JSON response and is returned as a string; this server does not parse it a second time. Four fields were null on the captured account, so no type is claimed for them. One account was captured, so which fields are always present is not established beyond the name.

Return the current season's glint totals for one account from GET /players/current_rewards. The measured public response carried a season_reward_info object with the season number and a glint figure per format. Some per-format glint fields were observed null on the captured account and carry no declared type; the wild and survival figures were observed as numbers. A missing figure is not evidence that the account earned nothing. One account and one season were captured; no claim is made about which formats carry a figure in general.

Return the previous season's glint totals for one account from GET /players/last_season_rewards. The measured public response carried the same season_reward_info shape as the current-season route, with the season number and a glint figure per format. Three per-format glint fields were observed null on the captured account and carry no declared type; only the wild figure was observed as a number. A missing figure is not evidence that the account earned nothing. One account and one season were captured. This tool is a separate route from the current-season one and no equivalence between them was tested.

Return one account's last completed focus from GET /players/last_focus_rewards. The measured public response carried a quest_data object with an id, the account, creation date and block, a name, item counts, a reward quantity and claim details. quest_data.name carries a format such as wild; it does not name an account. quest_data.rewards is a JSON-encoded STRING inside the JSON response and is returned exactly as received; this server does not parse it. Two fields were null on the captured account, so no type is claimed for them. One account was captured.

Return one account's unclaimed balances for one token from GET /players/unclaimed_balances. Both username and token_type are required: omitting token_type returns HTTP 200 carrying the message that player and token are required, which is an application error inside a success status rather than an HTTP failure. The measured response carried one row per reward type, each with the account, token, type, a string balance and a last-updated date, alongside a last_claim_date. On the captured account SPS returned rows while DEC and CREDITS returned an empty array, so an empty array means no unclaimed rows for that token, not an error. Only DEC, SPS and CREDITS were tried, so the accepted token_type set is not established.

Return one account's unclaimed-balance history for one token from GET /players/unclaimed_balance_history. Both username and token_type are required, and omitting token_type returns HTTP 200 carrying the message that player and token are required rather than an HTTP failure. The response is a bare array; each row carried a reward action, an id, the account, token, type, a string amount, a block number, a transaction id, dates, a destination account and a status. On the captured account SPS returned rows while DEC returned an empty array. Only DEC and SPS were tried on this route. This server applies its general 100-row and 256 KB result bounds to the array and does not claim the bounded answer is the full upstream history.

Look up the transaction object returned by GET /cards/trx_lookup for a real trx_id. A bare call, card_detail_id alone and username alone returned the same HTTP-200 application error saying that trx_id was missing; a real trx_id returned a trx_info object with id, block_id, prev_block_id, type, player, data, success, error, block_num, created_date, result, steem_price and sbd_price. data and result are JSON-encoded strings inside the JSON response and are returned as strings; this server does not parse them a second time. player is transaction account attribution, not donor provenance. BCX and donor were absent in the measured response. This route is a single-transaction event lookup and is not cached as static metadata.

List every catalogued endpoint and the evidence-backed dimensions known about it. This tool is offline and makes no upstream request.

Describe one catalogued endpoint, its parameters, result contract, evidence dimensions, and provenance. This tool is offline and makes no upstream request.

Read current token balances for the explicitly supplied players. The players selector can contain a comma-separated list; token_type is an upstream filter. No balances are totalled or converted. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read archived token balances for the explicitly supplied players. Use players: the upstream error message asks for username, but that alias returned HTTP 500 in the recorded probes. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public purchase, delegation and rental authority assignments for the explicitly supplied players. These are public account names, not credentials; this tool never changes authorities. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the quest rows returned for one player. JSON-encoded rewards strings are passed through unchanged. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read owned skin rows for one player. The captured response had 223 rows and no declared paging selector; the server may return only its bounded leading rows, not the complete inventory. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read liquidity-provider claim history for one player. In paired probes limit=1 returned one leading row; limit=2 with offset=1 repeated the two rows returned without offset. No working page-two cursor is established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read reward-delegation history for one player. In paired probes limit=1 returned one leading row, but limit=2 with offset=1 returned an empty array despite a populated response without offset. An empty offset result does not establish the end of history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read current reward-delegation rows for one player. Percent values are returned with their original wire types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the public recent team compositions for one player. The credential-bearing decrypt_key parameter is not exposed; this tool never accepts a decryption key. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream pack-purchase summary for one player and optional edition. This is a read operation and never purchases packs. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read card-airdrop eligibility and recorded claim information for one player. This tool never claims an airdrop. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream voucher balance and available figures for one player. Values, including negative values, are returned unchanged without interpretation. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the global DEC accounting figures. This endpoint has no declared player selector and does not report a player's DEC balance; use player_balances for that question. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read purchased-energy and purchase-tier information for one player. This tool never purchases energy. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one account's inventory with an explicit upstream type filter. Land reduced the observed response but retained Token rows, so type is not an exact row-type predicate; other type values are not verified. Optional item_detail_id filters the entire returned array locally before the 100-row/256-KiB result bound, without another request. Reports upstream and matched counts; truncation is explicit and no continuation is fetched. Preserves records, quantities and wire types. Inventory presence or absence does not establish eligibility to stake an item or complete holdings. Power Core item detail ID 322 was absent from the observed inventory response. Separate land_power_core_available and land_power_core_grouped tools expose the dated populated STK-LND-PCR contracts; availability is not a guarantee of staking eligibility. No credentials or mutations. Makes one logical GET with a 2-MiB transport bound.

Read the ranked leaderboard rows for the selected season, leaderboard and format. The default capture returned 20 rows; an explicit modern-format capture returned 26. The undocumented limit=2 and offset=2 probe returned the unchanged default rows, so no pagination controls are exposed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the selected season's leaderboard together with the requested player's separate rank record. Both season and username are required. The upstream returned HTTP 200 with an error object when season was omitted. The separate player record is retained even when the leaderboard list is locally shortened. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The leaderboard list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read token-holder rankings and the upstream's total_accounts and total_quantity figures. token_type is required; player optionally adds player_rank. The observed limit parameter returns leading rows. Offsets 0, 2 and 4 repeated the same two leading accounts with limit=2, so offset is not exposed and this is a top-N query, not a complete holder listing. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The richlist list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one player's token rank and balance as the upstream reports them. token_type and player are required by this tool; without player the upstream returned only token_type, which is not an account ranking. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the burn-event leaderboard and its totals. The captured upstream list had 200 detailed rows; this server returns a bounded leading portion while retaining totals. Points and burn quantities are decimal strings returned unchanged. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The leaderboard list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream full burn-event ranking route, whose captured response had 3344 compact rank/player/points rows. This server returns only a bounded leading portion, not the full ranking. The tested limit=2 and offset=2 query did not shorten or advance the response; no paging controls are exposed. Rank and points retain their string wire types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The leaderboard list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read presale leader rows and upstream total pack figures. Optional username adds a separate curr_player record, retained outside the bounded leaders list. The full upstream capture had 300 rows and exceeded 256 KiB, but a bounded list can be returned without dropping totals or the requested-player record. The tested limit=2 and offset=2 query had no effect; there is no exposed page-two control. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The players list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one season record by its explicit id, including its end time and reset block value. Omitting id returned HTTP 400. This is GET /season on the main API host, not /players/season; obtain a season id from a leaderboard response if needed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read grouped card-sale price and quantity summaries. The observed response had 2321 groups; only a bounded leading portion is returned. No working paging selector is established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read grouped card-rental price and quantity summaries, including season_qty and daily_qty. The observed response had 1710 groups; only a bounded leading portion is returned. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read current card rentals scoped by owner, renter or card_detail_id. These selectors were observed independently of Swagger. limit and take bound leading rows; offset=2 and skip=2 repeated the first two rows, these declared selectors remain forwardable for inspection but are not working pagination. This is not complete rental history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read individual listings for one card definition using id or card_detail_id. The captured sale query returned flat listing rows. type=rent with rental_type=season returned seasonal listings; omitting rental_type returned empty for the same card. Limit is a leading-row bound; no page-two control is established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read listing groups for explicitly supplied comma-separated card definition IDs. Each group has card_detail_id, foil and a nested result list. With two card IDs, limit=1 returned one listing inside each group. This is different from a global row limit. type=rent with rental_type=season returned seasonal listings. Groups are returned intact or refused if a group cannot fit the result bound. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read card market history for one player. include_sets is forwarded only when explicitly supplied; its effect has not been established. The capture had 126 rows and no proven paging selector. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read card rental history with an explicit player or username. Both account aliases returned the same two rows; limit and take bounded leading rows. offset=1 and skip=1 returned empty even though limit=2 without offset returned two rows. An empty offset result does not prove the end of history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream market transaction, USD volume and current rental aggregate figures. Preserve the wire values and units; this endpoint is not an individual player's history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read market status by one listing sell transaction id or comma-separated ids. Singular id returns one record when found, plural ids returns an array. An unmatched id returned an empty array. Supply exactly one selector; no record does not establish why it is absent. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read active market status by one listing sell transaction id or comma-separated ids. Singular and plural selectors have distinct object and array response shapes. Supply exactly one selector; this route is separate from completed status. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read completed market status by one listing sell transaction id or comma-separated ids. Singular and plural selectors have distinct object and array response shapes. Supply exactly one selector; returned payment quantities remain strings. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read listed card packages, retaining each package's cards intact. Only complete packages within the local result bound are returned; a package too large to fit is refused without dropping its cards. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public purchase price and fee settings. This makes no purchase and changes no setting. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public pack and promotional-card statistics. Pack editions may have different fields and nested types; all wire values are retained. This makes no purchase. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public liquidity reward rows for an explicitly supplied blockchain address. Decimal quantities are returned as strings. This never claims rewards and accepts no wallet credentials. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the existing battle queue records for an explicit username. This does not join a queue or submit a team. Captured queue fields such as mana_cap and team may be null even when status returns fuller data. Settings and team values retain their JSON-encoded string wire types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read battle status by explicit queue transaction ID. Obtain an ID from battle_queue. Team and settings are returned as upstream JSON-encoded strings. Unknown IDs returned HTTP 200 with an error string and are reported as errors, not successful battle records. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read a battle result by explicit queue transaction ID. Either captured opponent queue ID returned the same battle. Details, settings and reward information retain their original wire types, including JSON-encoded strings. Unknown IDs returned an error string. Oversized results are refused without dropping rounds or player data. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read upcoming tournament summaries. The observed public response had 58 rows. Optional username is forwarded; its effect is not established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the official upcoming tournament route. It returned exactly the same 58 rows as upcoming in the capture; do not infer permanent equivalence or a distinct complete dataset. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read in-progress tournament summaries. Optional username is forwarded only when supplied. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read completed tournament summaries. The captured upstream list had 200 rows. An undocumented limit=2 and offset=2 request returned the unchanged 200 rows, so no paging controls are exposed and the bounded result is not a complete archive. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read cancelled tournament summaries. The capture had 200 rows; no working pagination has been established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream mine listing for an explicit username. A tournament creator returned 200 rows; two player accounts, including a known entrant, returned empty arrays. Do not present this route as a player's complete participation history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read tournament details by explicit id. Players are locally bounded while rounds, num_players and other fields are retained. The tested player_limit=2 still returned all 19 players, so it is not an effective upstream bound. No credentials are accepted. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The players list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read brawl details for an explicit tournament id and guild_id. Omitting guild_id returned an error. Players are locally bounded while guilds and brawl rules remain intact. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The players list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read tournament matchups by id and round, scoped to a player or swiss_group. The captured group number 1 returned 21 matchups, and an explicit player returned six. Omitting both, group 0, or username alone returned empty; username is not a substitute for player. Nested battle references and participant records remain intact. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read upstream awarded and upcoming tournament prize aggregate figures without recomputing them. This does not claim any prize. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Search guilds by an explicit name filter. The unfiltered response exceeded the 2 MiB transport limit; a specific name returned one guild and an unmatched name returned no guilds. Other declared filters are forwarded without assuming their effectiveness. The bounded list preserves num_actionable_mail and other surrounding fields. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The guilds list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one guild by its explicit ID. The default capture included extra fields absent with ext=true; do not assume ext=true expands the response. Building, tournament and crest data retain their JSON-encoded string wire types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read guild membership rows for an explicit guild_id. The default capture returned 230 rows across statuses; status=active returned 30. Membership status is not inferred. Undocumented limit=2 and offset=2 did not shorten or advance active members, so no paging controls are exposed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read contributions for a guild and explicit building type. guild_hall and arena each returned 50 rows, while omitted type returned empty. Amounts and cumulative fields retain their original units and wire values; no complete contribution history or working pagination is established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read brawl records for an explicit guild. cycle selected one row; start_cycle and end_cycle selected the two captured inclusive endpoint cycles. Other tournament and date selectors remain forwarded but unverified. SPS payout quantities remain decimal strings and the bounded list does not establish a complete history. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The results list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read global brawl SPS payout totals and/or cycle records. Use the string 1 for include_total or include_cycles: true returned an empty object. Each section can be selected independently. The total is global even when cycle narrows records; it is not a guild or selected-cycle sum. Cycle records are bounded while a requested total is retained. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The sps_reward_records list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read current public settings from the API, cached for one hour per exact query. Matching version and config_version still returned the full settings body; they are not a delta protocol. The server never transcribes configuration constants into this tool. Uses a bounded success cache keyed by exact supplied query, otherwise makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the latest block number reported by the game API. This is not cached by the settings cache. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read scheduled maintenance windows and window_buffer_ms. Explicit date bounds are forwarded; the tested September range retained the same upcoming window, so complete filtering semantics are not established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The maintenance_windows list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one game transaction by explicit trx_id. Transaction data and result retain their JSON-encoded string wire types. An unknown ID returned an error object. This never submits or retries a game transaction. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read named transaction metric series from an explicit date. Comma-separated battles,battles-modern selected both series and from narrowed the captured history to two recent points each. The unfiltered capture was about 1 MiB; each returned metric series remains intact under the result bound. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the public VAPI health root, which reports status and application/version/environment metadata. This is a health read, not a claim that all game routes are available. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read conflict seasons. Without id the upstream returned 24 records; an explicit id returned one object, so the response shape depends on the selector. All wire values, including nullable prize settings, are preserved. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read a player's conflict reward-point record and reward_point_threshold with an explicit id or conflict selector. Both aliases selected the captured current conflict. Other declared mode/filter inputs are forwarded without presumed effectiveness. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The players list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read a player's recorded airdrop distribution for an explicit id or conflict. The conflict alias also returned conflict metadata, while id returned only distribution. No prizes are claimed; num_prizes is not recomputed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The distribution list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the conflict leaderboard, totals and prize metadata by id. The upstream returned 200 rows; the server returns a bounded leading portion while retaining totals and leaderboard_prizes. No working upstream pagination is established. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The leaderboard list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one player's conflict ranking by id and username. Despite the upstream leaderboard_with_player name, the captured response contained only player, not the whole leaderboard. Rank and contribution values retain their string wire types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read conflict configuration, current conflict, player statistics and wagons for an explicit username. Flag strings use 1: only_config=1 returned config alone, only_wagons=1 returned stats and wagons, and exclude_wagons=1 omitted wagons. only_config=true did not reduce the response. Returned wagons are bounded with other requested sections unchanged. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The wagons list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one wagon by explicit uid, retaining its complete card list and original contribution values. An unknown uid returned an empty object, which is reported as an error rather than a fabricated wagon. This never stakes or removes cards. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read eligible card groups for an explicit username. max_group_size=1 or 2 limited the UID sample inside each group, while qty and total_cards retained the full counted quantities. Do not equate returned UID count with all eligible cards. Each group remains intact and groups are locally bounded. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The groups list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public proposal rows. limit=2 with offsets 0 and 2 returned distinct pages which concatenated exactly to limit=4,offset=0 in the capture. Each call fetches one page only; vote weights and thresholds remain decimal strings. Other filters are forwarded as supplied. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the pending-proposal count for an explicit username. This is a read of the reported value, not a vote or proposal submission. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read recorded votes for an explicit proposal_id. Two pages of two voters matched the first four-row page exactly. Vote weights remain strings and approval remains boolean. This tool never casts or changes a vote. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public market asset summaries. assets accepts comma-separated asset names; PACKS and PACKS,LAND selected 15 and 18 rows. Unfiltered reads returned 979 rows and are locally truncated, not a complete inventory. An authorized player-specific PACKS read returned numOwned on all 15 rows; counts are passed through without inferring how listed items are counted. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The assets list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read estimated market prices for an explicit asset and detailId. PACKS/ALPHA returned minPrice as a string; wire types and currencies are preserved. This is an estimate, not an executable quote. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The prices list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read asset metadata by assetName. All 13 landing-page categories were captured. detailIds accepts comma-separated IDs, not a JSON array string; omission returns all available details, locally bounded. SKINS returned 788 records. Additional per-asset fields are preserved. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The details list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read account market purchases and sales. The public client uses types=purchase,sale and sort=desc; sale selected sales and asc selected older records. limit bounded returned rows. offset=1 did not select the second record of the unoffset response, so conventional row-offset paging is not established. No complete history claim. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the account listing items for one asset/detailId. PACKS/RIFT matched the corresponding row in all_listings. Preserve listing/item identities, currencies, prices and remaining quantities; this does not create or change listings. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read account listing items across assets, locally bounded. The observed response mixed PACKS, CONSUMABLES, SKINS and MUSIC. The route name does not override local truncation or establish completeness for every account. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the upstream owned and listed counts for one account and asset/detailId. PACKS/RIFT returned owned=0 and listed=2. Counts are returned unchanged; their arithmetic relationship is not inferred. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation offers for an explicit player. Require limit 1-100; one bounded GET, no automatic paging. Two pages of two matched four rows; amount asc/desc changed the observed ordering. Preserve numeric strings and all original fields. These are token delegations, not card-worker rentals. Status filled selected zero-available rows; do not infer filled state from the numeric offer status alone. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation bids for an explicit player. Require limit 1-100; one bounded GET, no automatic paging. Two pages of two matched four rows; amount asc/desc changed the observed ordering. Preserve numeric strings and all original fields. These are token delegations, not card-worker rentals. Status filled selected zero-available rows; do not infer filled state from the numeric offer status alone. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation rental records for an explicit player. Require limit 1-100; one bounded GET, no automatic paging. Two pages of two matched four rows; amount asc/desc changed the observed ordering. Preserve numeric strings and all original fields. These are token delegations, not card-worker rentals. Borrower/lender roles were checked in both directions. Pending and active selected numeric status 0 and 1 in the sample. Counterparty partial matching was verified on the player route only; other sort/status values remain unmeasured. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation rental records for an explicit player and borrower/lender role. Require limit 1-100; one bounded GET, no automatic paging. Two pages of two matched four rows; amount asc/desc changed the observed ordering. Preserve numeric strings and all original fields. These are token delegations, not card-worker rentals. Borrower/lender roles were checked in both directions. Pending and active selected numeric status 0 and 1 in the sample. Counterparty partial matching was verified on the player route only; other sort/status values remain unmeasured. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read legacy SPSP delegation rental records for an explicit bid transaction ID and limit of 1 to 100. A populated bid response matched the corresponding player rental record. Preserve numeric wire strings. Paging and sort effectiveness are not established; one bounded response, no automatic continuation. These are token delegation rentals, not worker-card rentals. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read legacy SPSP delegation rental records for an explicit player and limit of 1 to 100. One populated record was observed. Paging and sort behavior are not yet independently established. Preserve quantity, paymentAmount and pricePerToken as wire strings; these are token delegation rentals, not worker-card rentals. Returns one bounded response without automatic continuation. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation rental offers with an explicit limit of 1 to 100. Two pages of two transaction IDs matched the first four rows. Quantity bounds worked, including a 10000 exact range. Price filters accepted integer 1 but rejected decimal 0.001 with HTTP 400; values are forwarded without rescaling. A combined player, amount-ascending, maxPrice=1 and quantity-range probe returned only the selected player and in-range quantities. Other combinations remain unmeasured. These are token delegation offers/bids, not card-worker rentals. Quantities, prices and escrow retain their wire string types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the public V3 delegation rental offers lowest-price endpoint. Preserve its price string, or nullable price allowed by the official schema. No unit conversion, annualization, quote execution or card-rental inference is performed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read public SPSP delegation rental bids with an explicit limit of 1 to 100. Two pages of two transaction IDs matched the first four rows. Quantity bounds worked, including a 10000 exact range. Price filters accepted integer 1 but rejected decimal 0.001 with HTTP 400; values are forwarded without rescaling. A combined player, amount-ascending, maxPrice=1 and quantity-range probe returned only the selected player and in-range quantities. Other combinations remain unmeasured. These are token delegation offers/bids, not card-worker rentals. Quantities, prices and escrow retain their wire string types. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the public V3 delegation rental bids lowest-price endpoint. Preserve its price string, or nullable price allowed by the official schema. No unit conversion, annualization, quote execution or card-rental inference is performed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read outgoing SPSP delegation records; each returned player is a recipient of the explicitly requested player. Two pages of two matched the first four records. Preserve amount strings, rental fields and nullable dates. No currency conversion or card-delegation inference. One bounded GET; no automatic paging. Sort effectiveness is unmeasured. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read incoming SPSP delegation records; each returned player is a delegator to the explicitly requested player. A populated record matched the corresponding outgoing and pairwise reads. Paging is declared but not independently demonstrated on the one-row sample. Preserve amount strings, rental fields and nullable dates. No currency conversion or card-delegation inference. One bounded GET; no automatic paging. Sort effectiveness is unmeasured. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the directed SPSP delegation from explicit player to explicit target. The positive pair matched outgoing/incoming evidence; reversing that pair returned HTTP 404. A zero-amount historical object was also observed: object presence does not imply a current positive delegation. Preserve amount strings, rental fields and nullable dates. No currency conversion or card-delegation inference. One bounded GET; no automatic paging. Sort effectiveness is unmeasured. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read available Power Core item IDs for an explicit player and deed. Restricted to the verified STK-LND-PCR stake type. A populated public-client-shaped query was observed; earlier other-account empty results remain valid. Preserve UIDs. One bounded page; no automatic continuation. Availability is point-in-time API evidence, not a guarantee that a later stake action will succeed. No staking or bulk stake-change operation is performed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The ids list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Read grouped available Power Core item counts for an explicit player and deed. Restricted to the verified STK-LND-PCR stake type. A populated public-client-shaped query was observed; earlier other-account empty results remain valid. Preserve item_detail_id, name, item_count and string boost. One bounded page; no automatic continuation. Availability is point-in-time API evidence, not a guarantee that a later stake action will succeed. No staking or bulk stake-change operation is performed. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The items list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields. Supply exactly one plot_id (numeric or display label) or deed_uid; the original UID spelling is also accepted. Reference resolution may add one verified deed GET before the target GET, with a hard two-request limit. Populated resolved results include all three plot identities and resolution freshness.

Read one player's tradeable collector stickers. Two public featured accounts returned 26 and 49 rows with isTradeable=true. Preserve sticker identities, trade/list flags, cosmetic metadata and relative asset paths. One bounded GET, no automatic paging; at most 100 complete rows and 256 KiB. This is not the for-sale route and does not list, transfer or buy anything. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one player collector overview with binder summaries. Preserve original fields and relative asset paths. One GET, no card metadata fan-out, purchases or layout changes. Oversized objects are refused as a whole. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read one public collector binder by player and binder reference; the observed slug selected three pages and 27 card slots, plus sticker placements. Preserve original fields and relative asset paths. One GET, no card metadata fan-out, purchases or layout changes. Oversized objects are refused as a whole. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the full sticker-list route for one player; the observed four rows included ownership and trade/list flags plus cosmetic metadata. Preserve original fields and relative asset paths. One GET, no card metadata fan-out, purchases or layout changes. Lists are locally bounded; the route name does not promise complete holdings. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. The data list are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.

Read the complete public collector configuration: page/slot limits, claim availability, shop metadata, featured accounts and cosmetic definitions. The captured response was about 15 KiB. These are upstream configuration values; reading shop or claim metadata performs no purchase or claim. Preserve relative asset paths, nullable asset URLs and every returned field. Oversized configuration is refused as a whole, not partially truncated. Makes one logical GET request and does not auto-fetch continuation pages. Required inputs reflect tool policy as well as measured upstream requirements. Other declared filters are forwarded as supplied; their effectiveness is not implied by the schema. Array responses are locally limited to 100 rows and 256 KiB, with truncation reported in text and metadata. Oversized records are refused without partial fields.