rust.wiki

Bandit Camp Big Wheel: odds, house edge and expected result of your bets. Exact figures for the Big Wheel (https://rust.wiki/calculators/big-wheel): each number's chance, what it pays back per scrap and what the wheel keeps; for your bets the expected_result over the session, the return %, and the standard deviation per spin and per session (how far a real session typically lands from the average). The wheel layout (12 ones, 6 threes, 4 fives, 2 tens, 1 twenty) comes from fan guides only. The page also simulates whole sessions with a starting bank. Rust's in-game scrap wheel at Bandit Camp, not real-money gambling.

Rust blackjack: the best play for a hand, or the whole strategy chart. The blackjack page's strategy engine (https://rust.wiki/calculators/blackjack), an exact infinite-deck calculation under Rust's caboose rules: no doubling on a hand with an Ace, one split, 3:2 blackjack, and no dealer peek by default. With hand + dealer: the best play and every option's expected value per 1 scrap bet. Without: the full hard, soft and pairs charts (H hit, S stand, D double, P split) per dealer card, plus the house_edge_pct with perfect play (about 0.82% under Rust's rules). Rust's in-game scrap blackjack (caboose), not real-money gambling.

Sheep and cow breeding odds: genes, inbreeding, twins, wool/milk. The animal breeder page's maths (https://rust.wiki/calculators/animal-breeder). Each gene has two copies and the animal shows the better one; the young gets one random copy of each gene from each parent, so young_odds per gene is the chance it shows good / ok / bad. It also gets one random family mark from each parent and is inbred when they match (chance_inbred; null when marks weren't given). chance_all_good_not_inbred, chance_twins (needs a good-fertility mother) and expected_product_per_hour (wool or milk, inbreeding counted) follow. Gene numbers come from fan tools that read the game files (gene_confidence).

Browse or search the item catalogue. One page of live items (seasonal, obsolete and unreleased items are excluded from browsing but still resolve by shortname). Each result carries shortname, display_name, category, icon_url and is_craftable; fetch /items/{shortname} for everything else. Same ordering and cache as the /items page on the site (15 minutes).

Browse skins with the site's filters and sorts. One page of skin cards exactly as the /skins browser shows them: itemdefid, name, icons, category, item_collection, market_hash_name, flags (is_twitch_drop, is_limited_time, marketable, tradable, is_permanent...), price (canonical wiki price in cents, null when Steam has no listing), subscriptions (Workshop subscribers, the site's supply proxy), store_price (the original item-store price in cents), store_change_pct (market price vs store price) and released (date accepted into the store). Filters combine with AND. total is the filtered count; results are cached for 120 seconds per filter combination.

Build an Industrial Conveyor filter to paste into the game. The conveyor page's filter builder (https://rust.wiki/calculators/conveyor). filter_json is exactly what the in-game conveyor copies and pastes (a list of {TargetCategory, TargetItemName, MaxAmountInOutput, BufferAmount, MinAmountInInput, IsBlueprint}); paste it on the conveyor's filter screen. A conveyor holds 30 filters; unknown lists names that matched nothing.

Build cost, daily upkeep and raid cost of a base. The base cost calculator page's math (https://rust.wiki/calculators/base). build_cost is the total resources (a block's upgrade cost at its grade, a door's crafting recipe); upkeep is the tool cupboard's daily and weekly cost on the building blocks at Rust's default brackets (the same result as /calculators/upkeep/compute); raid_path gives each layer's cheapest standard explosive and the total sulfur to reach the loot. unknown lists inputs that matched nothing.

Raw materials to craft a list of items. Resolves every recipe down to raw materials, per unit (items made in batches, like gunpowder, are divided by their batch size), exactly as the craft calculator page does. raw_materials is the total, largest first; items echoes each input with its direct recipe; unknown lists inputs that matched no item.

Shots and time to kill through armour, per hit area. The damage calculator page's maths (https://rust.wiki/calculators/damage). Damage per hit = weapon damage x ammo x attachment x hit-area multiplier x (1 - protection); protection of every piece covering the area is added (cap 100%), +4% per metal insert. Per zone (head, chest, legs, hands, feet): protection_pct, damage_per_hit, shots_to_kill (null = never) and time_to_kill_s (fire rate plus reloads when the magazine runs out). Close range only - no damage falloff; shotguns assume every pellet hits. Limb multipliers are low confidence.

When a base decays once the Tool Cupboard runs out, piece or layer by layer. The decay page's maths (https://rust.wiki/calculators/decay): with no upkeep, an outside piece goes from full health to nothing in 1 h (twig), 3 h (wood), 5 h (stone), 8 h (sheet metal) or 12 h (armoured); inside pieces decay at a tenth of that. destroyed_in_hours counts from now (upkeep first). For layers, each layer behind the outer one decays at 10% until the one in front is gone, then at full speed. Vanilla server defaults.

Giant Excavator, quarries and pump jack: output and run time for your diesel. The excavator page's maths (https://rust.wiki/calculators/excavator): run time and output for the diesel. The Giant Excavator's yields per diesel are Facepunch's own (December 2021); the monument quarries' and pump jack's come from community guides (confidence). Vanilla server rates.

Power draw of a set of components, and what runs it. The electricity calculator page's math. total_draw is the summed power; supply says how many of each power source covers it at its best output (needed); batteries gives each battery's runtime_minutes on a full charge, or enough_output: false when the load is above what that battery can deliver.

Explosives needed to destroy a set of building pieces. For every explosive that can destroy all the given pieces: total units and sulfur, cheapest sulfur first; cheapest is the best single option. Single-explosive totals - damage adds up across explosives, so a mix can be cheaper (use /calculators/raid's damage_per_unit for that). Doors and deployables aren't covered yet.

What recycling a list of items yields. Expected outputs (quantity x per-unit yield x chance) per input and in total, for the chosen recycler.

Smelting time, wood burned and charcoal made. The smelting calculator page's math: time/seconds to smelt everything, outputs (metal fragments, sulfur, HQM, low grade fuel), wood_burned and charcoal_made (about 0.75 per wood), power_draw for the electric furnace, and fits_one_fill (false = you'll need to refill it). Ore a smelter can't process is listed in not_smeltable_here. Server-default speeds; modded servers differ.

Daily upkeep for a base. The upkeep calculator page's math: the block count walks Rust's default upkeep brackets to a blended daily rate, and each resource's daily upkeep is what was spent building times that rate (per_week = 7 days).

Overlay skins, baskets and indices on one date axis. The data behind rust.wiki/skins/compare: one shared dates axis and a series entry per token with key, name, icon_url, is_basket, is_index and prices aligned to the axis (null where that entry has no data yet). Skin and basket entries are prices in cents (a basket is the plain average of its members' prices); index entries are index levels rebased to 100. Spans over two years are downsampled to weekly points. Cached for 24 hours per parameter combination.

Executable buy-on-marketplace, sell-on-Steam flips. Every skin that can be bought on a third-party marketplace for less than it nets on Steam Community Market right now, as rust.wiki/skins/deals computes it. Per deal: buy_market and buy_price (the cheapest in-stock listing we poll, cents), sell_url (the Steam listing page), the two Steam references bid_gross/bid_net (highest buy order, and what you actually receive after Steam's 15% fee) and ask_gross/ask_net (lowest sell order, same), then for the chosen steam_ref: sell_price (the net proceeds), sell_gross, spread_abs (cents) and spread_pct. Only rows profitable under the chosen reference are returned. A stale buy order above a fresher ask is capped at the ask. Filters combine with AND; search matches the skin name case-insensitively. Marketplace links are not included. Recomputed every ~5 minutes from the marketplace poll.

Best crossbreeding layout from a pool of plant clones. The gene calculator's beam search, ported exactly: which clones to plant around the centre, how many of each, and what the centre will most likely become (with every outcome's chance). Uses the game's gene weights (red W/X 1.0, green G/Y/H 0.6).

What a plant will grow into from its neighbours. Every possible result for the centre plant with its probability, most likely first.

Bandit Camp games' rules: Big Wheel, blackjack, poker and slots. The rules behind https://rust.wiki/calculators/big-wheel, /calculators/blackjack and /calculators/poker-odds: the wheel's segments and payout, blackjack's table rules, poker's (no rake) and the slot machines' paytable. Each rule carries how sure it is (confirmed by Facepunch, corroborated, unconfirmed). Slot machine odds and the house's cut aren't published anywhere. These are Rust's in-game scrap games - nothing to do with real money.

Doors, walls and deployables ranked by sulfur to raid vs build cost. The data behind https://rust.wiki/building/best-value. doors, walls (walls, foundations and floors at every grade) and other (raidable deployables), each hardest to raid first. Every row has slug, name, health, raid - the cheapest single standard explosive (rockets, C4, satchel charges, explosive 5.56 ammo, beancans) as explosive (shortname), count and sulfur - and build, resource name -> amount (a building block's upgrade cost at its grade, a door's or deployable's crafting recipe). Building blocks add grade and type; doors and deployables add shortname, icon_url and url. explosives names the shortnames. Raid data cached for 24 hours.

One building piece: costs, durability, siblings. The piece's slug, display_name, grade, health and decay_hours, plus costs (build, repair and upkeep lists of item_name, amount or min_amount/max_amount, with shortname/icon_url when the material maps to a catalogue item), durability (up to ten entries each for explosive, melee and bullet damage: item_name, seconds_taken to destroy, required_items = how many of that weapon/explosive) and siblings - the same piece at every other grade, Twig to Armored. Cached for one hour.

CCTV camera codes by monument. The 12 monuments with working CCTV cameras and their Computer Station identifiers (60 codes). codes are the literal in-game console codes; when randomized is true the trailing **** is a per-wipe random 4-digit suffix posted near the camera in-game, not a fixed code. slug links to /monuments/{slug} (null for Cargo Ship, which is a moving monument). Fixed reference data.

Circuit simulator parts: every electrical part's inputs, outputs and rules. The parts and rules behind https://rust.wiki/calculators/circuit-simulator (Rust's power rules since the April 2024 rework): parts as [kind, name, shortname, group, inputs, outputs, settings], devices as [name, shortname, power draw], rules and caveats. The board and its solver run in the browser - build circuits on the page; for a plain power budget use /calculators/electricity/compute.

Damage calculator data: weapons, ammo, muzzle attachments, armour and suits. The data behind https://rust.wiki/calculators/damage: weapons (guns and bows whose ammo the model covers), ammo per ammo family as [name, damage multiplier, headshot multiplier, pellets override], attachments (muzzle damage multipliers), armour (projectile protection %, slot and layer: clothing goes under, armour over, dual takes both, single = hands/feet), suits, zones (hit areas and multipliers; low = low confidence), presets, rules and caveats.

When each dataset last changed and how often it refreshes. The quota-saver: for every dataset the API serves, updated_at (the newest timestamp actually in the table, UTC) and refresh_seconds (how often it can change), with the endpoints it feeds. Poll this cheap endpoint and only re-fetch a heavy payload such as /market/prices or /servers when its dataset's updated_at has moved; cache reference data (items, monuments, ...) locally since it only changes with Facepunch's monthly patch. Timestamps are read live from the database and cached for 60 seconds.

Code lock facts and what makes a door code easy to guess. The facts behind https://rust.wiki/calculators/door-code: the code lock's rules (facts: 4 digits, a shock per wrong guess, 8 wrong tries then a 15-minute lockout, guest codes), the ten most common four-digit codes (cited from DataGenetics' 2012 PIN study), the patterns the page flags as guessable and how long a full brute force takes. The API deliberately doesn't generate or check codes: the page makes them in your own browser and never sends them anywhere - open the page for a code. For a random code, send the user to the page (codes are generated in their browser).

Electricity data: every component's power draw, sources and batteries. The data behind https://rust.wiki/calculators/electricity. consumers and logic list every powered component with shortname, name, draw (power it needs to run) and note; logic parts (switches, gates, timers, splitters, branches...) have drawn 0 since April 2024. sources are the generators (max = best-case output, sizing says what that assumes) and batteries give capacity (rWm) and max_output (rW). mechanics explains how Rust power flows; verified is when the numbers were last checked and sources_cited where. Fixed data, re-checked after Facepunch balance patches.

Value a Steam account's Rust skins. Every Rust skin the account holds with quantity, unit price and value (cents), sorted by value, and the same attributes /skins filters on (collection, creator, item_shortname, item_name, est_supply, released_year, colors, and flags: limited_time, permanent, marketable, tradable, breakable, glows, commodity, drop), plus total_value, item_count, distinct_skins, a categories breakdown with share percentages, the owner's display name and avatar, and value_history (the current holdings re-priced at each of the last 365 days, in USD DOLLARS, not cents, at each day's Steam sale price - so its latest point can be below total_value, which is at current asking prices). found is false for private or empty inventories; stale is true when Steam was unreachable and the last stored snapshot was re-priced instead. Takes a 17-digit SteamID64 (use resolve_steam_profile for a profile URL or custom name); the inventory must be public. Served from the stored copy when the inventory was checked in the last 24 hours, otherwise read live from Steam. No key needed: keyless clients share a daily inventory cap; send your own free key (https://rust.wiki/api-keys) as X-API-Key for a private quota.

Most valuable inventories ever checked. The rust.wiki/inventory leaderboard: every inventory anyone has looked up, ranked by total value at its last check (values are re-priced each time an inventory is viewed or by the daily warmer for the top 20). Includes the network-wide totals. 20 per page. No key needed.

One saved daily snapshot. The inventory exactly as it was priced on that day: items with quantity and that day's price, total value and item count. Useful for 'what was this worth last month' comparisons. No key needed.

What an inventory is realistically worth. The inventory valued three ways, plus what selling would actually raise. at_asks is the headline number (each skin at its cheapest Steam listing, falling back to the best buy order); at_bids is every skin at its best buy order; at_recent_sales is every skin at its latest Steam median sale price (the inventory chart's basis). sell_now walks each skin's real buy-order ladder for the quantity held: units_sellable of units_held could be sold instantly for gross (what buyers pay) and net_after_fees (after Steam's 15%). biggest_ask_gaps lists the skins whose cheapest listing sits furthest above their recent sales - thin order books where the headline is least reliable. All cents. Uses the stored holdings (the last lookup) and current order books: never a live Steam call; look the inventory up first if found is false. No key needed. Use when asked what an inventory is REALLY worth or would sell for: asks vs bids vs recent sales, and instant-sell proceeds after Steam's 15% fee.

Inventory value over time. The inventory's value over time: the account's current holdings re-priced at each day's Steam SALE price (median sale), values in USD cents, oldest first - the line on the rust.wiki inventory chart. It shows how the market moved, not when items were bought. headline_total_value is the total at current Steam ASKING prices (lowest sell order) as of headline_checked_at, the number shown at the top of the inventory page; for thinly traded skins it can sit well above the latest point here. Only inventories that have been looked up have a series. Read from stored data: never a live Steam call. No key needed. Use this for the value-over-time graph's data points (any range, daily/weekly/monthly); get_inventory only carries a thinned one-year series. Look the inventory up with get_inventory first if it returns found=false.

Full item detail bundle. Everything the item page shows, in one response: item (name, description, category, icon, stack size, despawn seconds, craftable flag), recipe (components with quantities), blueprint_costs (unlock source, scrap cost, workbench tier), recycle (yields per recycler type with chance), repair, loot_sources (every crate/NPC/barrel that drops it, with chance_pct and amount, highest chance first), used_in (items this one is an ingredient of), skins (the first 24 skins by price, each with price and store_price in USD cents, subscriptions and released), skins_total and similar (six items from the same category). Page through all skins with /items/{shortname}/skins. Cached for 15 minutes.

All skins for an item, priced. Every skin for one base item, most expensive first (unpriced skins last, then by name) - the same list and order as the Skins tab on the item page. Each skin carries itemdefid, name, icon_url, market_hash_name, item_collection, workshopid, price (canonical wiki price, USD cents, null when nothing is listed), store_price (its original Rust item-store price, USD cents), store_change_pct, subscriptions (Workshop subscriber count), released and the tradable/marketable/banned flags. Prices refresh about every 12 minutes; this list is cached for 15.

The current Rust item store. What is purchasable in Rust's item store right now, in the three sections the wiki shows: limited_time (this week's rotation, most Workshop subscribers first), general (the permanent catalogue) and dlc_packs (bundles, by name). Each item carries itemdefid, name, icon_url, category, store_price (cents), market_price (its Steam Community Market price in cents, null when unlisted), rarity, item_collection, creator_name/creator_avatar_url, subscriptions, est_supply with est_supply_source (workshop subscribers for brand-new items, the market estimate otherwise), base_item_name and the usual flags. Also recent_rotations (the last six, newest first, is_current marks the open one), active_rotation_id and next_rotation_at (the open rotation's start + 7 days; rotations land on Thursdays). Steam's own purchase URL for any item is https://store.steampowered.com/buyitem/252490/{itemdefid}/{quantity}. Cached 30 minutes.

Past item-store rotations. Every weekly rotation, newest first (the open one included): id (the rotation slug, YYYY-MM-DD-HHMM, or General for the permanent catalogue), name (Facepunch's label when it had one, usually null), start, end (null while current), itemdefid_count and icons - every skin in it as {url, name}, DLC packs excluded. With search, only the rotations that sold a matching skin are returned (same shape, newest first), which answers "when was X in the store?". Full item lists via GET /store/rotations/{rotation_id}. Cached for an hour; searches are computed live.

Rust launch options that work, the myths, and a Steam launch line builder. The data behind https://rust.wiki/launch-options: groups of options Rust (Facepunch) and Unity 6 actually read, each with its value and what it does, plus myths (popular 'FPS boost' flags nothing shows Rust reads). With line: check.line is the cleaned launch line (known options only, one forced graphics API) and check.options says what each one is (rust, unity, myth, unknown, conflict) with any warning.

One loot table with every drop. The loot source's id and name plus drops, highest chance first: for each item shortname, display_name, icon_url, chance_pct (0-100), amount_min/amount_max and, for items that spawn damaged, condition_min_pct/condition_max_pct. Scraped from wiki.facepunch.com; cached for 30 minutes.

Market cap of the Rust skin market. The rust.wiki Market Cap page as data: total_value (cents), skin_count, unit_count, by_category ({category, value}) and top, every skin ranked by value with {itemdefid, name, icon_url, price, amount, value}. Supply is not something Steam exposes, so amount is the skin's Steam Workshop subscriber count - a stated approximation (subscribing is not owning) - and value is price x amount. Only marketable skins with a live Steam price and a linked Workshop submission are included. Cached for 15 minutes.

Skin market index series. The rust.wiki Market Index: a basket of skins rebased to 100 at the start of the window, like a stock index, built from Steam's daily price history (one point per day; weekly beyond two years). Returns dates (ISO dates), values (index level, 100 = the window's first day), constituent_count (skins that had a price at the baseline; baskets are capped at 300 constituents) and label. A skin whose history starts inside the window joins from its first price. Cached for 24 hours per parameter combination (history only gains a point every 6 hours); the full catalogue, every category and every collection are kept warm server-side.

Stonking, crashing and most-anticipated skins. The rust.wiki Insights page: stonking - the 10 skins trading closest to (or above) their all-time high, crashing - the 10 closest to their all-time low (each {itemdefid, name, icon_url, price, reference_price}, cents; the reference is that skin's own all-time high or low from Steam's multi-year history, skins with under 30 history points excluded), and anticipated - the 50 marketable skins with the most Steam Workshop subscribers ({itemdefid, name, icon_url, subscriptions}). Refreshed with each price-history run, about every 6 hours.

One monument with its loot sources. The same fields as /monuments for one monument plus loot_sources: every crate/NPC loot table that spawns at it (id, name, drop_count), alphabetical - fetch each with /loot-tables/{id}. Cached for one hour.

Rust's player count: live on Steam, every monthly peak since 2013, by region. The data behind https://rust.wiki/player-count. live is Steam's own count of everyone running Rust at the last check (updated_at); months is every monthly peak since 2013 as [YYYY-MM, peak] (from SteamCharts' public record of Steam's numbers); record the all-time monthly peak; years each year's peak; this_month and same_month_last_year for comparison; breakdown / regions split the players on the servers rust.wiki polls by region and server type (null when the server poll has nothing). Server players are always fewer than Steam's figure: Steam also counts menus, queues and untracked servers.

Rust player leaderboard: most kills, best K/D, hours and more. The leaderboard on https://rust.wiki/players: Rust players ranked by their official Steam stats. Boards: kills, kd (min 1,000 kills), headshots (headshots on anything), hours (public playtime only), accuracy (bullets that hit a player / fired, min 20,000 fired), scientists, animals, gathered (wood + stone + metal ore + sulfur ore), building (blocks placed), rockets, fish, deaths. Each result has rank, steamid, name, avatar, country, value / value_text, kills, deaths, kd, hours and updated (the date its stats were last read from Steam). Players are added when looked up on Player Stats or when their inventory is checked on rust.wiki, refreshed about weekly; only public game details are ranked and accounts with VAC or game bans never are. total is how many players qualify for the board.

Player profile, Rust stats and achievements. Profile summary (name, avatar, country, Steam level, account age), VAC/game bans, Rust playtime, every Rust stat Steam exposes grouped into Combat / Animals & NPCs / How you died / Gathering & loot / Building / Travel / Life on the island / Fishing / Music / Everything else, six headline figures (kills, deaths, K/D, headshots, bullet and arrow accuracy), and all 116 achievements with unlock dates. stats_private is true when the profile hides game details, in which case groups and achievements are empty.

Raid cost table: explosives and sulfur per building piece. The dataset behind the raid calculator. explosives lists every explosive the building durability data covers: shortname, name, icon_url, group (staples, other or siege), staple (true for rockets, C4, satchel charges, explosive 5.56 ammo and beancans - the page's default set), sulfur_per_unit and raw_cost_per_unit (the crafting recipe resolved down to raw resources such as sulfur, charcoal, metal fragments and low grade fuel, per single unit; both null for loot-only explosives like MLRS rockets), batch (units one craft makes: explosive ammo 2, mortar shells 2) and recipe_source (wiki = the wiki's own crafting data, fallback = Rust's standard recipe where that data has none yet, e.g. rockets). targets is every building piece with explosive data (slug, name, grade, health), each with costs - for every explosive that can damage it, required (how many destroy one piece), damage_per_unit and sulfur (null for loot-only) - and cheapest_staple, the single staple explosive that destroys it for the least sulfur. Damage from different explosives adds up, so a cheaper mix can be computed from damage_per_unit. Doors and deployables are not covered yet. Cached for 24 hours.

Recently wiped servers. Wipes detected across every online server in the window, newest first - the feed behind servers.rustprofit.com/wipes. A wipe is detected when a server's world_seed or world_size changes between two polls, or when the last-wipe time it advertises moves past our previous poll (for servers with A2S rules disabled). Each entry has detected_at, the old and new seed/size, and the full server record. Expect thousands of entries in the 24 hours after Rust's monthly forced wipe (first Thursday). Cached for five minutes.

Facepunch's Rust updates and devblogs. Every post from rust.facepunch.com/news, newest first. Each carries slug, title, summary, category (devblog, news, update, ...), published_date (UTC date), thumbnail_url, url (the official post, or this network's own write-up when has_blog_post is true) and has_blog_post. Polled every few minutes; the first page is refreshed the moment a new post is found.

One server in full. Everything the server's page shows except the live player names: the full public record (see /servers) read fresh, plus votes, rating (1-5 average) and rating_count, the last ten detected wipes (newest first, with the seed/size before and after), last_wipe_at, avg_wipe_cycle_hours across those wipes, next_wipe_estimate_at (last wipe + average cycle; a guess, not a schedule), next_force_wipe_at (Rust's monthly forced wipe) and map_preview - null until a RustMaps render exists for the server's seed/size, otherwise image_url, thumbnail_url, total_monuments, monuments ({type, x, y}), monument_types, land_percentage and the five biome_* percentages. Offline servers still resolve; unknown ids are 404. Player-count history is at /servers/{id}/history. Aggregates are cached for five minutes.

Player-count history for one server. The per-poll player_count/queued_count readings behind the server page's 24-hour chart, oldest first, as points of {t, players, queued}. One reading lands per poll cycle (roughly hourly); when the window holds more than 500 readings they are averaged into equal time buckets (resolution_seconds, null when the points are raw) so a response never exceeds 500 points. Also peak_players, avg_players and point_count. A server that has never answered a poll has an empty series. Cached for five minutes.

Site-wide totals and data freshness. The headline numbers from the servers.rustprofit.com homepage: online_servers, total_players and queued_players summed across every online server, tracked_servers (every row ever discovered, offline included), steam_global_players (Rust's concurrent player count from Steam, null if Steam did not answer), next_force_wipe_at (the first Thursday of the month at 2 PM US Eastern: 18:00 UTC during US daylight saving time, 19:00 UTC otherwise), the poller's configuration (poll_interval_seconds between cycles, offline_after_seconds before an unanswering server is marked offline, snapshot_retention_days of per-server history kept) and workers - the live heartbeat status of the discovery, polling and map-generation jobs, so you can tell how fresh the data is. Includes next_force_wipe_at (Rust's monthly forced wipe).

Full skin detail: price, order book, history, cross-market prices. Everything the skin's wiki page shows, as data. skin is the full catalogue record (creator, workshop title and dates, collection, flags, store price and availability, crafting components, glow/cutout ratios, colours). price is the canonical wiki price in cents and price_source says which side of the book it came from. orderbook is Steam's live book: lowest sell order, highest buy order, order counts, the buy_orders and sell_orders depth ladders ({price, quantity}, best first) and fetched_at; the headline price refreshes more often than the ladders, so they can briefly trail it. steam_history is the last year of Steam's own sale history (recorded_at, median sale price, volume; sale_basis false means Steam has no sale series and the points are our ask-price readings instead) - wider ranges via /skins/{itemdefid}/history. market_stats is the page's Community & Market Stats card: an archived SCMM snapshot (frozen September 2026) of supply_total/supply_total_estimated/supply_total_owners_estimated, Workshop subscriptions_current/ subscriptions_lifetime, favourited_current, views, votes_up/votes_down, market_24hr_value, market_168hr_value, market_last_30d_sales, market_rank_index, market_liquidity_score, the market high/low with their dates, change_7d_percent/change_30d_percent/change_90d_percent and ath_percent; null for skins SCMM never covered. `cros

One collection with all its skins. The collection's name, slug, count, total_value and avg_value (cents), released (the earliest member's store-acceptance date) and skins: every member as {itemdefid, name, icon_url, rarity, category, price} ordered by price, highest first. The collection's value-over-time series is GET /market/collection-value. Cached for 30 minutes.

One Workshop artist: every accepted Rust skin they made and what it's worth. The data behind https://rust.wiki/creators/: the artist's skins with prices (USD cents), count, total and average value, top skin, first and last release, and the split by item, collection and category.

Price and sales history for one skin on each marketplace. The skin's history on every marketplace rust.wiki tracks, Steam included. Per site in sites: listing is [day, low, close, qty] per UTC day - the lowest listing price we read that day (low the day's lowest reading, close the last) and how many listings stood behind it; sales maps a period to [day, volume, avg_price] rows - day and week are real sales buckets (day = the bucket's first day) from each site's own sales data: Rust.tm (years back), CS.Deals, DMarket, Mannco.store and RustSkins; r1 is Skinport's last-24-hours figure recorded once a day against the day it covers; r7 and r30 are a site's rolling 7- and 30-day figures as we read them that day. Prices are integer USD cents. Listing history starts 2026-10-30. Steam's own sale history is GET /skins/{itemdefid}/history. Updated through the day (listings every ~5 minutes).

Full Steam order book for one skin. Steam Community Market's current order book for the skin, straight from our scraper's latest snapshot: lowest_sell_order and highest_buy_order (cents; null when that side is empty), sell_order_count and buy_order_count, the COMPLETE sell_orders and buy_orders depth ladders as [{price, quantity}, ...] best price first (every level Steam publishes, not a top-N cut), and fetched_at, when the snapshot was taken. The headline ask is refreshed by a market-wide sweep every ~12 minutes; the depth ladders come from the per-item rotation (every few hours), so they can trail it slightly. 404 when the skin has no Steam order book (unmarketable items). Not cached: this is one indexed row.

Live price, order book depth, extremes and 7d/30d change for one skin. The compact price card the rust.wiki Discord bot's /price command shows, as data. All prices are integer USD cents: price_cents (the canonical wiki price - Steam's lowest sell order, or the highest buy order when nothing is listed), ask_cents and bid_cents (the two sides of Steam's book), sell_orders/buy_orders (how many orders stand on each side), sell_ladder and buy_ladder (the top five price levels on each side, best first, as {price, quantity}), ath_cents/atl_cents (the skin's all-time high and low from Steam's sale history), change_7d/change_30d (percent move of today's price against our closest Steam price reading 7 and 30 days back; null without enough history) and sales_30d (units sold on Steam in the last 30 days, null when none). Plus name, icon_url, market_hash_name and category. Cached for 5 minutes.

Steam sale history for one skin. Steam Community Market's own sale history for the skin, scraped from Steam's listing page: points of {recorded_at, price, volume} where price is Steam's median sale price for that interval in cents and volume the number of sales. Steam reports roughly hourly points for the recent month and daily beyond; ranges of a year or more are condensed to one point per day (median price, summed volume). Empty when Steam has no sale series for the item (unmarketable skins). History goes back to the skin's first sale, as far as 2015. Refreshed continuously; the full series is cached for an hour.

One rotation's full item list. One rotation as the wiki's /store/rotation page shows it: rotation (id, name, start, end, itemdefid_count - the number of items that still resolve in the catalogue) and its items split into limited_time, general and dlc_packs, each item in the same shape as GET /store, including today's market_price and is_available_on_store (a past rotation can still contain evergreen catalogue items). Cached for an hour.

Every tea recipe: berries, Mixing Table slot order, buff and duration. The data behind https://rust.wiki/teas. Each tea has name, shortname, tier (Basic, Advanced, Pure), ingredients (item, qty, shortname), slot_order / slots (the Mixing Table order for Basic teas - order matters: Scrap and Warming Tea use the same berries), effect, duration_minutes and note (Advanced and Pure values predate Rust's 5 Nov 2026 tea nerf). notes covers stacking and mixing rules. Sourced from Facepunch's wiki and devblogs (sources, verified).

Most populated servers right now. The online servers with the most players right now - the same query behind the rust.wiki Discord bot's /servers command - as a compact list: id, name, players, max_players, country and the server's page url. Use /servers?sort=players for the full records. Cached for 60 seconds.

Current Rust Twitch and Kick drops. The live drops campaigns (Twitch and Kick: round, dates, general and streamer drops with the skin each one gives), the most valuable drop skins ever by Steam price, and past rounds - the data behind rust.wiki/drops.

One Facepunch devblog: what it added - new skins, their value, drops, player peak. The data behind https://rust.wiki/updates/ (devblogs only): Facepunch's summary and link, the RustProfit blog explainer when there is one, every skin released in the update's window (until the next devblog) with its price (USD cents, Steam lowest listing; first 60 listed, skin_count for all), how many were store skins vs Twitch/Kick drops, their total value now, the drop collections, that month's Steam player peak and the previous / next devblog. Devblog slugs come from get_rust_updates.

Upkeep decay brackets and decay times. Rust's dedicated-server upkeep defaults (the decay.bracket_* and decay.duration_* ConVars, as most servers run them). brackets are applied in order to a base's block count: the first 15 blocks cost 10% of their build cost per day, the next 35 cost 15%, the next 75 cost 20%, and every block beyond 125 costs 33.3% (blocks null = unbounded); a base's blended daily rate is the block-weighted average of the brackets it fills, paid in the resources each piece was built from. decay_hours is how long an unmaintained piece of each grade takes to decay completely. Fixed constants, no computation happens server-side.

Every weapon's damage, DPS, fire rate, magazine, reload and range. The data behind https://rust.wiki/weapons: every gun, bow, launcher and main melee weapon with damage per bullet/pellet (standard ammo), pellets (shotguns), hit (damage x pellets), raw dps (hit x rpm / 60 - ignores reloads, recoil, armour and falloff), magazine, reload_s, range_m (damage falloff start-end) / range_end, ammo, workbench (level to craft; null = loot only, 0 = no bench) and notes. Checked against Facepunch's wiki and patch notes (sources, verified); Facepunch rebalances weapons often.

One world entity with its loot. The entity's slug, display_name, is_npc, npc_hp, icon_url and loot_source_id (null when it drops nothing), plus drops - its five likeliest drops (shortname, display_name, icon_url, chance_pct, amount_min, amount_max) - and drop_count, the full number of distinct drops. The complete table is /loot-tables/{loot_source_id}. Cached for one hour.

Dates with a saved daily snapshot. Every date (newest first, up to 400) on which a daily snapshot of this inventory was stored, plus totals: each of those days' total value in cents (that day's holdings at that day's prices). Snapshots are written when an inventory is looked up; fetch one with /inventory/{steamid}/snapshots/{date}. No key needed. Only inventories someone has looked up have snapshots. totals gives each saved day's total value (that day's holdings at that day's prices).

Every loot source (crates, NPCs, barrels). One page of loot sources, alphabetical. Each carries id, name (Facepunch's own loot-table name, e.g. Elite Tier Crate), drop_count (how many distinct items it can drop) and icons (the icons of its four likeliest drops). Fetch the full drop table with /loot-tables/{id}. Cached for 30 minutes.

All 60 fixed monuments. Every fixed-location monument, alphabetical, in one response (no pagination - the set is 60 and static). Each carries slug, name, tier (1-3, null for safe zones and minor monuments), is_safezone, has_radiation and radiation_level, recyclers (count on site), has_tunnel_entrance (underground rail), has_chinook_drop_zone, allows_patrol_heli_crash, no_build_area_sqm and icon_url. Moving monuments (Cargo Ship) are not included. Cached for one hour.

Skin collections with counts and values. Every skin collection (about 750, e.g. Forest Raiders, Abyss): name, count (members), total_value and avg_value (cents, over the priced members only; null when nothing in it is priced) and icons, one {url, name} per member skin. The collection's URL slug is its lower-cased name with non-alphanumerics collapsed to - (Forest Raiders -> forest-raiders), which is what GET /skins/collections/{slug} takes. Cached for 30 minutes.

Workshop artists behind Rust's skins, by total value. Everyone whose Workshop skins Facepunch accepted into Rust (https://rust.wiki/creators): steamid, name (from their latest skin), avatar_url, count of accepted skins, total_value (sum of their skins' Steam lowest listings, USD cents), newest release date and a few icons of their priciest skins.

Make a Rust key bind command (auto-run, crafting, chat, gestures...). The bind maker page (https://rust.wiki/calculators/bind-maker). Returns the bind line to paste into the F1 console and writecfg to save it. Without preset: every preset with its fields and suggested key, the bind syntax and the key names.

Plant grow time, clones per cut, yield bonus and water use. The farm planner page's maths (https://rust.wiki/calculators/farm-planner): time to ripe = the plant's base time / (1 + 25% per G), x1.5 unfertilized; stages splits it into Seed, Seedling, Sapling, Fruiting and Mature to ripe; yield_bonus_pct is +25% per Y; clones_per_cut adds one per two Y; water is per plant per tick, +10% per W. Harvests are relative (Facepunch publishes no base amounts). For the best gene layout use /calculators/genetics/best.

Plan a loot room: which item categories go in which box, with each box's filter. The conveyor page's loot-room planner: each category needs (its item types x fill) slots; categories go biggest first into the tightest box they fit, spilling across the emptiest boxes when none is big enough. Each box gets the conveyor filter_json for its categories; not_enough_room says what didn't fit.

Resolve a profile URL or vanity name to a SteamID64. Turns any of the accepted identifier forms into a 17-digit SteamID64. Does not fetch the profile. Turn a steamcommunity.com/id/... or /profiles/... link, or a custom URL name, into the SteamID64 the inventory and player tools need.

Console and server commands. One page of Rust console/server commands, alphabetical. Each carries command, syntax, description, category (Rust's own ConVar namespace, e.g. server, gather), command_type (command or variable), default_value (variables only) and permission_required (null when any player can run it). Cached for 30 minutes.

Search the RustProfit blog's Rust guides. Published guides from blog.rustprofit.com (monuments, recyclers, farming, base building, raiding, gear, NPCs, wipes, update explainers), best match first: every word must appear somewhere in the guide, and title matches rank above summary and tag matches, which rank above body-text matches. Link the url when citing one. Rust how-to guides from blog.rustprofit.com; cite and link the url.

Item name / shortname typeahead. Up to 25 live items matching q, best match first: a case-insensitive substring match on the display name OR the shortname, plus trigram similarity on the display name so typos still resolve (asault finds the Assault Rifle) - the same ILIKE + similarity search the site's item pickers use. Each result is {shortname, display_name, category, icon_url}; use the shortname with /items/{shortname}. For filtered, paginated results use /items?search= instead. Cached for 5 minutes per query.

Browse, filter and search the server list. One page of servers with the same filters, ordering and five-minute cache as the servers.rustprofit.com list and its hub pages (/country/de, /vanilla, /solo, /gather/2x ...). Each result is the full public server record: identity and connect details (ip, game_port, query_port, connect as a steam:// URI), map, world_seed, world_size, country/country_name, live current_players/max_players/queued_players, the kind (official/modded/vanilla) and is_* flags, password_protected, vac_enabled, gather_rate with its gather_bucket, group_limit with its group label, tags, owner-supplied description (first 500 characters), banner_url, website_url, discord_url, first_seen_at/last_seen_at/last_polled_at, the aggregates votes, rating (1-5 average, null when unrated) and last_wipe_at, and the server's page url plus embeddable widget_url/badge_url. Ties in every sort are broken by id so pages never overlap.

Skin name typeahead. Up to 10 skins whose name matches q, best match first (the same ILIKE + trigram search the site's search boxes use). Each result is {itemdefid, name, icon_url}; use the itemdefid with the other skin endpoints. For filtered, paginated results use GET /skins with search= instead.

Browse or search Workshop submissions. One page of submissions. Each carries workshopid (the Steam published-file id), title, author_steamid64, preview_image_url, submitted_at (UTC ISO-8601, may be null), accepted and accepted_itemdefid (the in-game item definition id when Facepunch accepted it - use it with /skins/{itemdefid}), target_item_tag, subscriptions and vote_score (Steam's 0-1 score; both null when Steam has not reported them). Same filters, ordering and cache as the /workshop page.

World entities: animals, NPCs, resource nodes. One page of world entities (anything not tied to one monument), alphabetical. Each carries slug, display_name, is_npc, npc_hp (null for resources) and icon_url. Cached for one hour.

Expected loot from a run of crates, barrels and NPCs. The loot simulator page's exact statistics (https://rust.wiki/calculators/loot-simulator): every item each container can drop is rolled on its own chance, with an amount between the table's min and max. For the whole run, each item gets expected_amount (average total), chance_at_least_one and best_chance_per_container; expected_item_stacks is how many item stacks the run gives on average. Chances come from the game's loot tables (the /loot-tables data). Random opens are done on the page. Loot source names/ids come from list_loot_sources.

Build and check a Skin Lab outfit: wear-rule clashes, attachments, total price and the 3D link. Puts the pieces on in order, the way the viewer and the game do. Pieces that can't be worn together (the game's own wear rules: two pieces clash when they occupy the same under-layer or over-layer body area - a Coffee Can Helmet and a Metal Facemask both cover the head) are reported in clashes with the piece they conflict with and why; the first piece wins and the later one is left out of the link, exactly as the viewer would; a second piece for a viewer slot that's already filled is a clash too. invalid_attachments lists attachments a gun doesn't accept or that fight for the same attachment slot; errors lists pieces that couldn't be resolved (unknown item, or a skin that isn't in 3D yet). slots is the normalised outfit (slot, item, skin, price), total_price the sum of the chosen skins' Steam lowest listings in USD cents (default looks cost nothing; unpriced counts skins with no listing), valid is true when nothing was dropped, and viewer_url opens the outfit in rust.wiki/skin-lab. Use to put together or check a whole Rust outfit (e.g. 'hoodie with the Tempered skin, metal facemask, AK with a holosight'): it applies the game's wear rules, flags pieces that can't be worn together and why, checks gun attachments, totals the skins' Steam price, and returns a viewer_url showing the outfit in 3D. Find skin itemdefids with search_skins or skinlab_get_item.

One Skin Lab item with every skin it can be viewed in, in 3D. The item as in /skin-lab/items plus skins: every skin with 3D textures, most expensive first, each with itemdefid, name, price (USD cents, Steam lowest listing; null = not on the market), icon, its own viewer_url and wiki page. Guns also carry attachments (what they accept - see /skin-lab/attachments). Every skin of one item that can be viewed in 3D, each with its own viewer_url and price (USD cents).

A Skin Lab 3D viewer link for one item or skin. Answers "can I see this skin in 3D?". With a known item and a processed skin: available_in_3d: true, the viewer_url that opens rust.wiki/skin-lab with it on, and embed ({o, mode} - the same piece the "View in 3D" card on the item and skin pages loads). A real skin that has no 3D textures yet gives available_in_3d: false with the reason and a fallback_url showing the item's default look. Unknown items are 404 with suggestions. Use when someone asks to SEE a skin or item: returns a rust.wiki/skin-lab link that opens it in 3D (available_in_3d=false says why not, with a fallback link). Share viewer_url with the user.

Items and skins you can view on the 3D player model (Skin Lab). Every item Skin Lab has a 3D model for (clothing, armour, guns and tools, deployables, building skins, vehicles), in viewer order. Each row has shortname, name, slot / slot_name (where the viewer puts it), group, worn (false = stood beside the player rather than worn), female_model, takes_attachments, skins_in_3d (accepted Workshop and built-in skins with 3D textures), cheapest_skin / priciest_skin (Steam lowest listing, USD cents), viewer_url (the item in its default look) and the wiki page. More skins are added as they're processed. Skin Lab is rust.wiki's 3D try-on viewer for Rust skins. Use this to see which items and slots it covers; give the user the viewer_url so they can open it.

Render a Skin Lab outfit, gun or item as an image (WebP/PNG). Returns {status: "done", url, cached, width, height, format} with a permanent image URL (same request = same URL; images are cached), plus outfit (the normalised pieces, their Steam prices and total_price in USD cents, and any clashes / invalid attachments dropped exactly as /skin-lab/outfit reports them), viewer_url (the same outfit in the interactive 3D viewer) and render_quota. A render that takes longer than wait seconds answers 202 {status: "queued", position, retry_after} - call again with the same parameters (no extra quota) after Retry-After seconds. 429 when the render queue is full or a quota is used up. New images count against a separate render quota (100 per key per UTC day); cached images don't. Use when someone wants to SEE an outfit, skin, gun or item: returns the rendered image inline (you can look at it and show it) plus a permanent image URL, the interactive 3D viewer link, the outfit's pieces and total Steam price. pieces uses the same format as skinlab_build_outfit (find skins with search_skins / skinlab_get_item); a gun with attachments in item view = mode weapon. Rendering a new image takes a few seconds; if it says pending, call again with the same arguments. Keyless use shares a small daily render budget.

Weapon attachments: what each gun accepts and what each attachment does. From the game's own attachment data (as Skin Lab uses it). Each attachment has shortname, name, slot (muzzle, sight, underbarrel, magazine, internal, targeting - one attachment per slot), description, effects (readable: damage x0.75 = 25% less damage, aimcone_hip +2 = wider hip-fire spread) and the raw stats multipliers (scalar) and additions (offset). With weapon: that gun's slots and accepts (the attachments that fit it). Without: every gun's accepted list plus every attachment. Which attachments a Rust gun takes and what each does (damage, recoil, zoom...).