kleinanzeigen-mcp
Provides read-only access to kleinanzeigen.de classifieds, enabling search for listings, retrieval of full listing details by ad id, browsing commercial seller profiles and listings, and lookup of category and location ids.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@kleinanzeigen-mcpSearch for a used bicycle in Berlin"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
kleinanzeigen-mcp
A read-only, robots-clean MCP server over kleinanzeigen.de, the German classifieds site.
What it does
Tool | What it answers | Requests |
| One page of listings matching a search query. | 1 |
| One listing in full, by ad id. | 1 |
| Profile and listings for one commercial seller. | 1 |
| Category ids matching a name. | 0 — bundled dataset |
| Location ids matching a name. | 0 — bundled dataset |
| Shop slugs for commercial sellers matching a name. | 1 |
Related MCP server: marktplaats-mcp
Install
Node 22 or newer is required. Four channels install the same build from the same release — they differ only in who does the fetching, and nothing propagates between them.
Channel | Who it is for | Line |
npm / npx — primary | anyone with an MCP client |
|
Claude Code | one line, no JSON |
|
Claude Desktop | no JSON editing at all | download the |
Claude Code plugin | the server and the skill together |
|
run-from-clone | development |
npm / npx — any MCP client
The package is kanzeigen-mcp.
There is no install step and nothing to build. Point your client at npx and let it fetch the package on first run:
{
"mcpServers": {
"kleinanzeigen": {
"command": "npx",
"args": ["-y", "kanzeigen-mcp"]
}
}
}That block goes in your client's config file — claude_desktop_config.json for Claude Desktop, .mcp.json for Claude Code, the equivalent for anything else. Restart the client afterwards.
To verify by hand, without a client:
npx -y kanzeigen-mcpClaude Code
claude mcp add kleinanzeigen -- npx -y kanzeigen-mcpAny environment assignment goes before the --. Everything after the -- is the command Claude Code runs, so a variable placed there becomes an argument to npx rather than an environment variable:
claude mcp add kleinanzeigen -e KLEINANZEIGEN_MCP_RATE_LIMIT_MS=3000 -- npx -y kanzeigen-mcpClaude Desktop — the MCPB
Download kanzeigen-mcp-<version>.mcpb from the latest release and open it. Claude Desktop installs it and offers the one knob below as a form field, so nothing here needs a config file.
Two things are worth knowing before you pick it. The bundle ships unsigned, so the install dialog warns — self-signing fails its own verification, and a real certificate is a purchase nobody has made. And the format has no update mechanism: an installed .mcpb is as current as the day it was downloaded, and nothing will ever prompt you.
Claude Code plugin — the server and the skill
/plugin marketplace add IIxauII/kleinanzeigen-mcp
/plugin install kanzeigen@kanzeigenConfiguration
KLEINANZEIGEN_MCP_RATE_LIMIT_MS — the minimum gap between requests, in milliseconds.
Unset means 1500 ms.
{
"mcpServers": {
"kleinanzeigen": {
"command": "npx",
"args": ["-y", "kanzeigen-mcp"],
"env": { "KLEINANZEIGEN_MCP_RATE_LIMIT_MS": "3000" }
}
}
}Development
Run from a clone. This is the development path rather than an install channel — it is the only one that yields a tree the drift check and the fixture-capture scripts can run in.
git clone git@github.com:IIxauII/kleinanzeigen-mcp.git
cd kleinanzeigen-mcp
npm install
npm run buildnpm run build produces a single-file ESM bundle at dist/index.js plus two sidecar datasets beside it. Point a client at it by absolute path:
{
"mcpServers": {
"kleinanzeigen": {
"command": "node",
"args": ["/absolute/path/to/kleinanzeigen-mcp/dist/index.js"]
}
}
}npm test # the whole suite
npm run typecheck # tsc --noEmit, which is the real typecheck
npm run build # tsup, into dist/Parser tests run against committed fixtures: hand-captured out of band by a dev-time script — never by the server — minimised to the DOM the parser actually reads, and redacted. The redaction rule is everything personal or identifying in the captured markup, including attributes the parser never reads: a pass aimed only at the fields the parser touches is how partner-ad ids and shop names once survived in tracking attributes. A test pins the rule.
Maintainer procedure — regenerating the two bundled datasets, running the drift check, and cutting a release — lives in docs/maintenance.md, because it addresses someone standing in a clone rather than someone who installed this.
Further reading: SPEC.md for the full contract, CONTEXT.md for the vocabulary every name in the codebase uses, and docs/adr/ for the decisions behind the posture.
Available Tools
6 toolsfind_categoryFind categoriesARead-only
Category ids matching a name. Always returns candidates — names and slugs collide, so only the numeric id identifies a category.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | A German category name, optionally qualified as "Parent > Child". |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | Yes | |
| stale | Yes | |
| matches | Yes | |
| fetched_at | Yes | |
| source_url | Yes | |
| stale_reason | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavior beyond the readOnlyHint: it warns that matches always come back as candidates because names and slugs collide, and that only the numeric ID is authoritative. This is valuable context that prevents an agent from assuming a single, clean match.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tightly worded sentences: the first front-loads the core purpose, and the second adds only the essential caveat about collisions and ID authority. Every clause earns its place, with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read-only lookup tool with a full input schema, an output schema, and readOnlyHint annotation, the description covers the key operational caveat an agent needs. Nothing important is missing for correct invocation and interpretation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the query parameter is already well described as a German category name with optional parent qualification. The tool description adds general context about ambiguity but does not add new parameter-level details, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: finding category IDs by name. The follow-up sentence explains the result shape (candidates) and the unique identifier, distinguishing this from sibling find tools operating on locations and shops.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied: call this tool when you have a category name and need the corresponding numeric category ID. However, it does not explicitly state when not to use it or name alternatives, so the guidance remains implicit rather than directive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_locationFind locationsARead-only
Location ids matching a name or postcode. Always returns candidates — a postcode can map to several locations.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | A German place name, optionally qualified as "Bundesland > Ort". A five-digit postcode matches nothing: the postcode layer's ids are absent from every source this dataset may read. Pass a postcode to search_listings' free-text `location` instead, which the site resolves itself — silently picking when the postcode spans several locations. |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | Yes | |
| stale | Yes | |
| matches | Yes | |
| fetched_at | Yes | |
| source_url | Yes | |
| stale_reason | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations readOnlyHint=true already cover the safety profile. The description adds the behavioral trait that it always returns candidates, which is useful, but the erroneous assertion that a postcode can match contradicts the schema's statement that postcode-layer ids are absent, weakening the transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the core purpose. However, the 'or postcode' clause is misleading and does not earn its place, since the schema explicitly denies postcode matching; a corrected version would be fully concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter, read-only lookup with an output schema, the definition is nearly complete: it covers the query format, the postcode exception, and the correct alternative tool. The only completeness gap is the internal contradiction between the top description and the parameter schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the query parameter is richly documented with format, qualification syntax, and the postcode exception. The tool description adds no new parameter meaning beyond the redundant 'name or postcode' phrase, so it stays at the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool returns location IDs for a name or postcode, which is a clear resource and output. However, the claim that postcodes are matched is contradicted by the parameter schema, which explicitly says a five-digit postcode matches nothing, so the stated purpose is partly misleading.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The query parameter description gives explicit guidance: a German place name optionally qualified as 'Bundesland > Ort', and it routes postcode queries to search_listings' free-text `location` instead. It names the alternative tool and the condition for using it, leaving no ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_shopFind shopsARead-only
Shop slugs for COMMERCIAL sellers matching a name. Makes a live request, unlike the other resolvers. A match may be a mention in a shop's profile text rather than its name, so check before using one.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The commercial seller's name, passed to the directory's full-text search unchanged. | |
| page | No | ||
| category_id | No | ||
| location_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| page | Yes | |
| count | Yes | |
| stale | Yes | |
| matches | Yes | |
| page_size | Yes | |
| fetched_at | Yes | |
| source_url | Yes | |
| stale_reason | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description adds meaningful behavioral details: the request is live/network-dependent, and matches may be loose profile-text mentions rather than exact name hits. This helps the agent set expectations about latency and result accuracy.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no filler. It front-loads the core purpose, then adds the live-request differentiator and the important matching caveat. Every sentence adds necessary operational or behavioral value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists and annotations already signal safety/open-world expectations, the description covers the critical caveats: live request behavior and the possibility of profile-mention matches. It could be more complete by explaining the optional filter parameters, but the overall context is sufficient for correct invocation in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 25%, and the description only meaningfully covers the 'name' parameter by stating it is passed to full-text search unchanged. The 'page', 'category_id', and 'location_id' parameters receive no explanation in either the schema or the description, so the agent has to infer their semantics from names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states exactly what the tool returns ('Shop slugs for COMMERCIAL sellers matching a name') and clearly distinguishes it from sibling resolvers by noting it 'makes a live request, unlike the other resolvers.' This tells the agent both the resource and the query intent without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides useful invocation context: it performs a live request rather than using cached resolver data, and it warns that matches may be mentions in profile text rather than actual shop names. It does not explicitly name alternative tools or give strict when-not-to-use conditions, but the context is clear enough for an agent to choose correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_listingGet listingARead-only
One listing in full, by ad id.
| Name | Required | Description | Default |
|---|---|---|---|
| ad_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | No | |
| ad_id | No | |
| flags | No | |
| price | No | |
| stale | Yes | |
| title | No | |
| images | No | |
| posted | No | |
| seller | No | |
| status | Yes | |
| postcode | No | |
| attributes | No | |
| fetched_at | Yes | |
| source_url | Yes | |
| category_id | No | |
| description | No | |
| image_count | No | |
| location_id | No | |
| listing_type | No | |
| stale_reason | No | |
| location_name | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds a small amount of behavioral context by saying 'in full,' indicating a complete listing is returned, but it doesn't mention edge cases like missing IDs or unavailable listings.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short phrase, front-loaded with the most important information: one listing, full detail, identified by ad id. There is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter retrieval tool with an output schema and read-only annotation, this description is complete enough. The agent knows what resource is returned, how to identify it, and can rely on the schema for the response shape.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. 'by ad id' clearly maps the single required parameter ad_id to the identifier of the listing to fetch, which is sufficient for this one-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource ('one listing') and the lookup mode ('in full, by ad id'), making the tool's purpose clear. It distinguishes itself from search_listings by emphasizing a single full record rather than search results, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for retrieving a single listing when you already have its ad id. It does not explicitly state when to choose it over siblings like search_listings or get_shop, leaving that inference to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_shopGet shop page and inventoryARead-only
Profile and listings for one COMMERCIAL seller. Private sellers have no shop page and cannot be reached by this server.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | ||
| keywords | No | ||
| max_price | No | ||
| min_price | No | ||
| shop_slug | Yes | ||
| category_id | No | ||
| location_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| page | Yes | |
| shop | Yes | |
| count | Yes | |
| stale | Yes | |
| status | Yes | |
| listings | Yes | |
| fetched_at | Yes | |
| source_url | Yes | |
| stale_reason | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful context by restricting the tool to commercial sellers, but it does not disclose behavior around pagination, filtering semantics, or what happens when a private or invalid shop_slug is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no filler. The primary purpose and the key limitation are both front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although annotations and an output schema reduce the burden, the description is too thin for a tool with 7 parameters and 0% schema coverage. It lacks parameter semantics, pagination/filtering context, and explicit routing to sibling tools, so an agent would still have to guess important invocation details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate. It only hints that shop_slug refers to a commercial seller's shop. The meaning and combined behavior of page, keywords, max_price, min_price, category_id, and location_id are left entirely unexplained, which is a significant gap for a tool with 7 parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the resource and scope: 'Profile and listings for one COMMERCIAL seller.' It distinguishes the tool from siblings by explicitly noting that private sellers have no shop page, so an agent can tell this is for a specific commercial shop rather than search listings or find shops.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when a specific commercial seller's shop and inventory are needed. It also gives a clear exclusion: private sellers are not reachable. However, it does not explicitly name sibling alternatives such as find_shop or search_listings, so the routing guidance is not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_listingsSearch listingsARead-only
One page of listings matching a search query. Promoted listings repeat on every page; high-volume queries drift between pages, so a listing can be missed or seen twice across a walk.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | ||
| sort | No | ||
| radius | No | ||
| ad_type | No | ||
| buy_now | No | ||
| keywords | No | ||
| location | No | ||
| shipping | No | ||
| max_price | No | ||
| min_price | No | ||
| category_id | No | ||
| location_id | No | ||
| poster_type | No | ||
| shipping_carrier | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| page | Yes | |
| sort | Yes | |
| range | Yes | |
| stale | Yes | |
| total | Yes | |
| clamped | Yes | |
| listings | Yes | |
| reachable | Yes | |
| fetched_at | Yes | |
| source_url | Yes | |
| stale_reason | No | |
| organic_count | Yes | |
| promoted_count | Yes | |
| location_resolution | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond the readOnlyHint and openWorldHint annotations by explaining concrete consequences: promoted listings repeat, high-volume queries drift between pages, and listings can be missed or seen twice across a walk. This is exactly the kind of behavioral context an agent needs to avoid assuming stable pagination or complete coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The core purpose is front-loaded, followed by a critical pagination caveat. Every sentence earns its place, and the structure makes the warning prominent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 14 optional parameters and 0% schema description coverage, the description is incomplete. It captures the core purpose and pagination pitfalls but offers no guidance on parameter combinations, defaults, or how to construct a valid search. The output schema exists, so return values are covered, but agent-facing invocation guidance remains thin.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the burden of explaining parameters, but it only vaguely references a 'search query'. It does not explain any of the 14 parameters such as sort, radius, ad_type, buy_now, min_price, max_price, category_id, or location_id. Parameter names and enums provide some self-evident meaning, but the description itself adds almost no semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource ('listings') and operation ('matching a search query'), and clarifies it returns only 'one page' of results. It distinguishes itself from siblings like get_listing (single listing) and get_shop/find_* by focusing on search over listings. The wording is precise and immediately actionable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for searching listings and that pagination is involved, but it does not explicitly say when to prefer it over alternatives such as get_listing, find_category, or find_location. It also does not mention when not to use it or how to resolve prerequisite IDs. Usage context is clear but exclusions and alternative routing are left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v1.0.0- First observed
find_category - First observed
find_location - First observed
find_shop - First observed
get_listing - First observed
get_shop - First observed
search_listings
TDQS
Scored across 6 tools
Each tool targets a distinct action: searching listings, fetching a listing, fetching a shop, or resolving category/location/shop identifiers. The only potential confusion is between find_shop and get_shop, but their descriptions make the resolver-vs-retrieval distinction clear.
All tool names use a consistent lowercase snake_case verb_noun pattern: search_, get_, and find_ prefixes map predictably to their behavior. The naming convention is uniform and easy to infer.
Six tools is a well-scoped size for a classifieds browsing server. Each tool serves a clear purpose without redundancy or unnecessary bloat.
The core read-oriented workflows are covered: search listings, view listing details, resolve categories/locations, and inspect commercial shops. Minor gaps exist around reliable pagination and private-seller profile access, but agents can work around these using the available tools.
Maintenance
Related MCP Connectors
Search and browse global classifieds across 80 markets. No auth required for read-only access.
Search MCP servers, MCP clients and AI agents, and retrieve listing details. Free, read-only access.
Read-only product discovery, merchant trust, shipping and returns for SVV-Schatzoekers.
Hosted Amazon Seller Central and Amazon Ads MCP server for Claude, ChatGPT, Cursor, and agents.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceSearch Kleinanzeigen.de, Germany's largest classifieds site, via MCP tools without API keys.1MIT
- AlicenseAqualityBmaintenanceRead-only MCP server for Marktplaats.nl (Dutch classifieds) that lets agents search listings and read price, specs, condition, delivery, location, and seller details.33 npmMIT
- FlicenseNot gradedqualityBmaintenanceEnables read-only access to Kleinanzeigen.de listings, including compact search, listing details, availability checks, and route calculations with optional distance and driving information.-
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to search Kleinanzeigen listings by keyword, category, location, price and seller type, with extra server-side filtering for title matches and required or excluded terms. It also retrieves full ad details, downloadable photos for visual inspection, category attributes, and seller reputation information.2MIT