tlidb APItlidb.com ↗
Access Torchlight: Infinite legendary gear data via 2 endpoints — slot listings with affix lines and implicit stats, plus full item detail pages.
What is the tlidb API?
The tlidb.com API exposes Torchlight: Infinite legendary (unique) gear data across 2 endpoints, returning up to dozens of fields per item including required level, implicit base stats, legendary affix lines, corroded-variant affixes, and drop metadata. The list_legendary_gear endpoint enumerates every legendary item within a given gear slot such as STR_Helmet or One-Handed_Sword, while get_legendary_gear returns the full detail record for a single item by its page slug.
curl -X GET 'https://api.parse.bot/scraper/8fd2a3b7-e685-414e-b940-65f79760bb16/list_legendary_gear?lang=cn&slot=STR_Helmet' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace tlidb-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: tlidb.com legendary gear — browse a slot, then drill into detail."""
from parse_apis.tlidb_com_api import Tlidb, GearSlot, Language, InputNotFound
client = Tlidb()
# List all legendary helmets for the STR archetype (Chinese locale).
for gear in client.gear_summaries.list(slot=GearSlot.STR_HELMET, lang=Language.CN, limit=5):
affixes = ", ".join(a.text for a in gear.legendary_affixes)
print(f"{gear.name} (lv {gear.level}) affixes: {affixes}")
# Drill into the first ring to see full detail (flavor text, drop sources, etc.)
ring = client.gear_summaries.list(slot=GearSlot.RING, lang=Language.EN, limit=1).first()
if ring is not None:
detail = ring.details(lang=Language.EN)
print(f"\n{detail.name} — {detail.season}")
print(f" flavor: {detail.flavor_text}")
print(f" drop sources: {detail.drop_sources}")
print(f" base item: {detail.base_item_name}")
for ca in detail.corroded_affixes:
print(f" corroded: {ca.text} (tier {ca.tier})")
# Point-lookup by item code discovered from the earlier list.
try:
item = client.gears.get(item=ring.item)
print(f"\nLooked up {item.name}, item_id={item.item_id}, drop_level={item.drop_level}")
except InputNotFound:
print("Item not found")
print("\nexercised: gear_summaries.list / GearSummary.details / gears.get")
Lists every legendary gear item of one gear slot (the wiki's slot pages, e.g. STR Helmet, Claw, Ring), one row per item, in the order the site shows them. Each row carries the item code, localized name, required level, the legendary affix lines (text, tier, modifier id), the corroded-variant affix lines when the site publishes them, and the item's fixed implicit base stats (implicit_stats), which are fetched from the site's item tooltip one request per item (a slot holds roughly 4 to 20 items; lookups are capped at 60 and any item whose tooltip could not be read is listed in implicit_stats_coverage.failed with implicit_stats null). implicit_stats is an empty array for items that have no base stats (e.g. Divinity Slates) and corroded_affixes is empty when the slot has no corroded section. slot_label is the site's localized name of the slot. Text fields are in the requested language. An unknown slot code is rejected before any request is made.
| Param | Type | Description |
|---|---|---|
| lang | string | Wiki language for names, affix text and slot_label. |
| slotrequired | string | Gear slot code. Weapon and armor slots follow the site's codes such as STR_Helmet or One-Handed_Sword. |
{
"type": "object",
"fields": {
"lang": "language code the texts are in",
"slot": "gear slot code as requested",
"items": "array of legendary gear rows: item (code usable in get_legendary_gear), name, level (integer required level), level_text (site's level label), legendary_affixes (array of {text, tier, modifier_id}), corroded_affixes (same shape, corroded variant), implicit_stats (array of fixed base stat lines, null when the tooltip could not be read), slot, slot_label, icon_url",
"total": "number of items in the slot",
"slot_label": "localized slot name from the site, null when the page has no base-affix table",
"implicit_stats_coverage": "object {fetched: count of items whose implicit stats were read, failed: array of {item, reason}}"
},
"sample": {
"data": {
"lang": "cn",
"slot": "STR_Helmet",
"items": [
{
"item": "Rock_Lizards_Skull",
"name": "岩石巨蜥之颅",
"slot": "STR_Helmet",
"level": 4,
"icon_url": "https://cdn.tlidb.com/UIV2/Common/Icon/UI/Textures/EquipCommon/NoAtlas_112_160/Icon_Equip_Helmet_Epic_401_112.webp",
"level_text": "需求等级 4",
"slot_label": "力量头部",
"implicit_stats": [
"+235 该装备护甲值"
],
"corroded_affixes": [
{
"text": "+100 该装备护甲值",
"tier": 0,
"modifier_id": "51420110"
}
],
"legendary_affixes": [
{
"text": "+50 该装备护甲值",
"tier": 1,
"modifier_id": "51420111"
},
{
"text": "+(80–100) 最大生命",
"tier": 1,
"modifier_id": "51420121"
}
]
}
],
"total": 16,
"slot_label": "力量头部",
"implicit_stats_coverage": {
"failed": [],
"fetched": 16
}
},
"status": "success"
}
}About the tlidb API
Slot Listings
The list_legendary_gear endpoint takes a required slot parameter — the site's gear slot code, for example STR_Helmet, Claw, or Ring — and returns an ordered array of every legendary item in that slot. Each row includes the item code (usable directly as the item input of the detail endpoint), a localized name, an integer level, the level_text label as the site displays it, and the full set of legendary affix lines with text, tier, and modifier id. The response also surfaces implicit_stats_coverage, an object that reports how many items' implicit stats were successfully fetched (fetched) alongside any failures as {item, reason} pairs. An optional lang parameter controls the language for all text fields and the slot_label.
Item Detail
The get_legendary_gear endpoint accepts an item slug (such as Hunting_the_Eye_of_the_Kraken) and returns the full item record: localized name, integer level, drop_level, season label (null when absent), the site's numeric item_id, an icon_url, base_item code and name, corroded-variant affix lines, implicit base stats, flavor text, and drop source information. The lang parameter applies to all localized text fields. Both endpoints share the same language-switching mechanism, making it straightforward to retrieve data in multiple locales.
Coverage and Language
Data covers all gear slots present on the tlidb.com legendary wiki pages, including weapon types and armor slots distinguished by stat class (STR, DEX, INT variants). The lang parameter is optional on both endpoints; when omitted the API defaults to the site's default language. Localized fields include item names, affix text, and slot labels. The slot_label field may be null when a slot page lacks a base-affix table.
The tlidb API is a managed, monitored endpoint for tlidb.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when tlidb.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official tlidb.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a Torchlight: Infinite gear browser filtered by slot, required level, and affix keywords.
- Compare legendary affix lines across all items in a given slot to find best-in-slot candidates.
- Populate a build-planner tool with implicit base stats and legendary affix tiers from
get_legendary_gear. - Track season-labeled items by reading the
seasonfield from detail responses. - Generate a localized gear wiki mirror by iterating slots with the
langparameter across supported languages. - Identify corroded-variant affix changes for all items in a slot using the corroded affix lines in listing rows.
- Map item drop sources and drop levels for farming-route calculators using
drop_leveland drop source fields.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does tlidb.com have an official developer API?+
What does `list_legendary_gear` return for each item, and how specific can the slot filter be?+
items array includes the item code, localized name, integer required level, level_text, legendary affix lines (with text, tier, and modifier id), and implicit stats where available. The slot parameter must be one of the site's slot codes — for example STR_Helmet, One-Handed_Sword, or Ring. There is no freeform text search within a slot; you retrieve all items for the slot and filter client-side.Are set items or non-legendary rarities covered?+
What happens when `implicit_stats_coverage` reports failures in the listing response?+
implicit_stats_coverage object includes a fetched count of items whose implicit stats were successfully read and a failed array of objects with item and reason fields. Items in the failed array will still appear in the items array but their implicit stat fields will be absent or partial. Use the item codes in failed with get_legendary_gear to attempt a direct detail fetch.Can I retrieve gear data for multiple slots in a single request?+
list_legendary_gear accepts one slot value per call and returns items for that slot only. To cover multiple slots you make one request per slot. You can fork this API on Parse and revise it to batch slot queries or add a multi-slot aggregation endpoint.