# Tradera Marketplace Scraper (`automation-lab/tradera-scraper`) Actor

Scrape Tradera auctions and buy-now listings for Swedish resale price monitoring, seller tracking, and ecommerce market research.

- **URL**: https://apify.com/automation-lab/tradera-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Tradera Marketplace Scraper

Extract auction and fixed-price listings from Tradera, Sweden's major resale marketplace.

Use this actor to monitor prices, follow sellers, collect category inventory, and build Swedish ecommerce market datasets without running a browser.

### What does Tradera Marketplace Scraper do?

Tradera Marketplace Scraper collects listing data from Tradera search result and category pages.

It accepts a keyword such as `iphone` or a full Tradera URL.

The actor parses the server-rendered Next.js data embedded in the page.

That keeps runs fast and affordable.

It can extract simple listing rows or optionally open each listing page for richer detail fields.

### Who is it for?

Resellers use it to compare auction prices before buying inventory.

Brands use it to monitor second-hand supply and gray-market products.

Analysts use it to size resale demand in Sweden.

Marketplaces use it to benchmark prices and shipping offers.

Ecommerce teams use it to detect popular models, conditions, and seller behavior.

Researchers use it to build historical datasets from public listings.

### Why use this actor?

✅ It is focused on Tradera rather than generic ecommerce pages.

✅ It returns structured listing data ready for CSV, JSON, Excel, or API workflows.

✅ It supports both keyword searches and pasted filtered URLs.

✅ It can keep costs low by avoiding detail pages unless you need them.

✅ It stores source URLs and scrape timestamps for reproducible analysis.

### What Tradera data can I extract?

| Field | Description |
| --- | --- |
| itemId | Tradera listing identifier |
| title | Listing title |
| url | Public listing URL |
| itemType | Auction or fixed-price style type |
| price | Current visible price or bid |
| buyNowPrice | Buy-now amount when available |
| totalBids | Number of bids shown in search data |
| endDate | Auction or listing end time |
| sellerAlias | Seller display name |
| imageUrl | Main image URL |
| shippingMinCost | Lowest visible shipping cost |
| condition | Detail-page condition when enabled |
| description | Detail-page description when enabled |

### How much does it cost to scrape Tradera listings?

This actor uses pay-per-event pricing.

There is a small start charge for each run.

Then you pay per listing extracted.

Current pricing is $0.005 to start a run plus tiered per-listing pricing.

The BRONZE per-listing price is $0.000028233, or about $0.028 per 1,000 listings before tier discounts.

Keep `includeDetails` disabled when you only need search-level fields.

Enable `includeDetails` when descriptions, visits, seller rating, category name, or image galleries matter.

### How to scrape Tradera search results

1. Open the actor on Apify.

2. Enter a search query such as `iphone`, `lego`, `omega`, or `volvo`.

3. Set `Maximum listings` to the number of rows you need.

4. Leave `Open listing detail pages` off for the fastest run.

5. Start the actor.

6. Export the dataset as JSON, CSV, Excel, or via API.

### How to scrape a Tradera category or filtered URL

Open Tradera in your browser.

Apply the category, query, or filters you want.

Copy the full URL.

Paste it into `Tradera search or category URL`.

The actor will keep your URL parameters and paginate with the `page` parameter.

Use this mode when a Tradera filter is easier to create in the website UI than through actor fields.

### Input example

```json
{
  "searchQuery": "iphone",
  "maxItems": 20,
  "includeDetails": false,
  "maxRequestRetries": 3
}
````

### Search URL input example

```json
{
  "searchUrl": "https://www.tradera.com/search?q=lego",
  "maxItems": 50,
  "includeDetails": true
}
```

### Output example

```json
{
  "itemId": 731665422,
  "title": "iPhone",
  "url": "https://www.tradera.com/item/340186/731665422/iphone",
  "itemType": "Auction",
  "price": 1,
  "priceCurrency": "SEK",
  "totalBids": 0,
  "sellerAlias": "Jacob1996",
  "shippingMinCost": 59,
  "sourceSearchUrl": "https://www.tradera.com/search?q=iphone&page=1",
  "page": 1,
  "position": 1
}
```

### Tips for better results

Use Swedish keywords when possible.

Try category URLs for cleaner niche datasets.

Start with 20 results to validate your query.

Increase `maxItems` after you confirm the output matches your target.

Use `includeDetails` only when detail-only fields are required.

Use exact model names for pricing research.

Use broad category terms for inventory monitoring.

### Detail enrichment

When `includeDetails` is disabled, the actor extracts data from search result pages only.

This is the fastest mode.

When `includeDetails` is enabled, the actor opens each listing URL.

That can add description, visits, category name, condition, seller rating, and more image URLs.

Detail enrichment makes one extra HTTP request per listing.

For large datasets, test a small sample first.

### Integrations

Send new Tradera rows to Google Sheets for daily monitoring.

Load CSV exports into Excel or Power BI for price analysis.

Call the dataset API from a repricing script.

Connect Apify webhooks to Slack for newly discovered products.

Use Make or Zapier to append rows to your internal inventory tracker.

Store periodic runs in a database for historical price curves.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradera-scraper').call({
  searchQuery: 'iphone',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/tradera-scraper').call(run_input={
    'searchQuery': 'iphone',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~tradera-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"iphone","maxItems":20}'
```

### MCP usage

You can use this actor from Claude Desktop or Claude Code through Apify MCP.

Use the tool URL with the actor selected:

`https://mcp.apify.com/?tools=automation-lab/tradera-scraper`

Claude Code setup:

```bash
claude mcp add apify-tradera "https://mcp.apify.com/?tools=automation-lab/tradera-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-tradera": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tradera-scraper"
    }
  }
}
```

Example prompt:

"Scrape 30 Tradera listings for used iPhones and summarize the median visible price."

Example prompt:

"Collect Tradera LEGO listings with detail pages and identify sellers with repeated listings."

### Data quality notes

Tradera values can change quickly because auctions receive bids.

Use `scrapedAt` to understand when a row was collected.

Prices are returned in SEK.

Some fields are optional because not every listing exposes the same data.

Shipping options may include several carriers.

The actor records the minimum visible shipping cost when possible.

### Common use cases

Auction arbitrage research.

Second-hand electronics monitoring.

Collectibles price tracking.

Seller inventory snapshots.

Brand protection monitoring.

Category supply analysis.

Used goods demand research.

### Limitations

The actor extracts public Tradera pages only.

It does not log into accounts.

It does not place bids or buy items.

It does not bypass private user data.

If Tradera changes its Next.js page structure, extraction logic may need an update.

Very filtered pages may return fewer listings than requested.

### Legality

This actor collects publicly visible listing information.

You should use the data responsibly.

Review Tradera's terms and applicable laws for your use case.

Do not collect personal data you do not need.

Do not use scraped data for spam, harassment, or prohibited profiling.

### FAQ

#### Why did I get fewer listings than requested?

The search or category may have fewer visible results, or Tradera may stop returning new unique items on later pages.

Try a broader query or a category URL.

#### Why is description empty?

Description is available from listing detail pages.

Enable `includeDetails` to collect it.

#### Can I scrape ended auctions?

The actor follows what the supplied Tradera URL returns.

If your URL shows ended or completed listings publicly, paste that URL into `searchUrl`.

#### Can I scrape seller pages?

This version is optimized for search and category URLs.

Seller-page support can be added later if demand justifies it.

### Related scrapers

Use other automation-lab ecommerce actors when you need data outside Tradera.

Examples include marketplace scrapers, ecommerce product scrapers, and classifieds scrapers published under `https://apify.com/automation-lab/`.

### Changelog

Initial version extracts Tradera listing data from server-rendered search pages.

Optional detail enrichment collects richer listing fields.

### Support

If a run fails, provide the run URL, input, and a short description of what you expected.

Small reproducible inputs are easiest to diagnose.

### For developers

The actor uses HTTP requests and Cheerio.

It reads `#__NEXT_DATA__` from Tradera pages.

No browser automation is used in the initial version.

The default memory target is 256 MB.

### Final notes

Start small.

Validate your query.

Scale the run after reviewing the first dataset.

Use detail enrichment only when needed.

Export results from the Apify dataset tab or API.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for on Tradera. Leave empty when using a full search URL.

## `searchUrl` (type: `string`):

Optional full Tradera URL, for example a category page or a filtered search URL. Overrides the search query when provided.

## `maxItems` (type: `integer`):

Maximum number of Tradera listings to save to the dataset.

## `sortBy` (type: `string`):

Optional Tradera sortBy URL value. Leave empty to use Tradera's default relevance/order or the value already present in searchUrl.

## `includeDetails` (type: `boolean`):

Visit each listing page to collect description, visits, category name, seller rating, condition, and the full image gallery. This is slower because it makes one extra request per listing.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "searchQuery": "iphone",
  "maxItems": 20,
  "includeDetails": false,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "iphone",
    "searchUrl": "",
    "maxItems": 20,
    "sortBy": "",
    "includeDetails": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradera-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "iphone",
    "searchUrl": "",
    "maxItems": 20,
    "sortBy": "",
    "includeDetails": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradera-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "iphone",
  "searchUrl": "",
  "maxItems": 20,
  "sortBy": "",
  "includeDetails": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/tradera-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/tradera-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tradera Marketplace Scraper",
        "description": "Scrape Tradera auctions and buy-now listings for Swedish resale price monitoring, seller tracking, and ecommerce market research.",
        "version": "0.1",
        "x-build-id": "Qd7dwx8DKwWYGIWjG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradera-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradera-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~tradera-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradera-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~tradera-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradera-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "🔎 Search query",
                        "type": "string",
                        "description": "Keyword to search for on Tradera. Leave empty when using a full search URL."
                    },
                    "searchUrl": {
                        "title": "Tradera search or category URL",
                        "type": "string",
                        "description": "Optional full Tradera URL, for example a category page or a filtered search URL. Overrides the search query when provided."
                    },
                    "maxItems": {
                        "title": "📦 Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Tradera listings to save to the dataset.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort value",
                        "type": "string",
                        "description": "Optional Tradera sortBy URL value. Leave empty to use Tradera's default relevance/order or the value already present in searchUrl."
                    },
                    "includeDetails": {
                        "title": "Open listing detail pages",
                        "type": "boolean",
                        "description": "Visit each listing page to collect description, visits, category name, seller rating, condition, and the full image gallery. This is slower because it makes one extra request per listing.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```