# Back Market Scraper (`scraptivo/backmarket-scraper`) Actor

Collect refurbished product listings from Back Market across 17 countries by search term or URL, with optional product details and customer reviews.

- **URL**: https://apify.com/scraptivo/backmarket-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Back Market Scraper** collects refurbished product listings from [Back Market](https://www.backmarket.com) and turns them into structured data for price monitoring, catalog building, and review analysis. Provide a search term such as `iphone`, a Back Market URL, or a country selection across 17 markets, then export name, price, grade, rating, and product URL to JSON, CSV, or Excel. Use it to compare refurbished pricing, track grades, and schedule recurring collection. Pricing is **$1.50 per 1,000 products**, with optional product details and reviews at the same rate.

### What can you automate with Back Market Scraper?

- **Build refurbished catalogs** — Collect products from search terms or Back Market search, category, and product URLs.
- **Compare refurbished vs new prices** — Export current price, original price, currency, grade, and stock on each listing.
- **Cover 17 markets** — Run against Germany, Austria, Australia, Belgium, Spain, Finland, France, UK, Greece, Ireland, Italy, Japan, Netherlands, Portugal, Sweden, Slovakia, and the United States.
- **Enrich specs and variants** — Add description, specifications, variants, and image galleries when **Include Product Details** is on.
- **Collect customer reviews** — Add ratings, comments, and attribute scores when **Include Reviews** is on.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Pricing analysts | Compare refurbished prices, grades, and original retail prices across countries. |
| E-commerce researchers | Monitor iPhone, laptop, and appliance inventory on Back Market. |
| Review analysts | Pull customer reviews and attribute scores for quality studies. |
| Resellers and buyers | Track grade, price, and stock for target models over time. |

### What data can you collect from Back Market?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `productId`, `listingId`, name, model, brand, URL | Identify each listing and open the live page. |
| Commercial | price, formatted price, original price, currency, grade | Compare refurbished and new pricing by cosmetic grade. |
| Reputation | rating, review count | Rank products by customer sentiment. |
| Variant | color, subtitle, category | Separate storage, color, and SIM variants. |
| Detail fields | description, specifications, variants, images | Appear when **Include Product Details** is on. |
| Reviews | rating, comment, date, country, attachments | Appear when **Include Reviews** is on. |
| Market | `countryCode`, `locale`, `sourceType` | See which country and input type produced each row. |

Listing-card fields are always collected. Specifications, variants, and reviews appear only when the corresponding toggles succeed.

### How to use Back Market Scraper

1. Open the [Back Market Scraper](https://apify.com/scraptivo/backmarket-scraper) on Apify.
2. Enter search queries, choose a country, or paste Back Market search, category, or product URLs.
3. Toggle **Include Product Details** and/or **Include Reviews** when you need richer rows.
4. Run the Actor — it writes one dataset row per product.
5. Export the dataset or connect it to your workflow.

At least one of `searchQueries` or `startUrls` is required.

```json
{
  "searchQueries": ["iphone"],
  "country": "DE",
  "maxItems": 20,
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviews": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example workflow

#### Monitor refurbished iPhone prices in Germany

1. Schedule a daily run with `searchQueries` = `["iphone"]` and `country` = `"DE"`.
2. Enable **Include Product Details** when you need storage, color, and specification tables.
3. Enable **Include Reviews** when review text and attribute scores matter for your analysis.
4. Export results to Google Sheets through a webhook after each run.
5. Deduplicate user-side against `productId` or the product URL when combining runs.

The Actor does not merge results across runs — those steps happen in your pipeline.

### Automate and integrate your results

- **Schedules** — Run **daily** on high-change categories such as smartphones, or **weekly** for broader catalog snapshots.
- **Webhooks** — Push completed runs into Google Sheets, Make, Zapier, Slack, or a pricing database.
- **Exports and API** — Download JSON, CSV, Excel, or HTML from the Apify Console, or start a run from the API:

```shell
curl -X POST "https://api.apify.com/v2/acts/scraptivo~backmarket-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["iphone"],
    "country": "DE",
    "maxItems": 20
  }'
```

Use `productId` as the stable deduplication key across runs.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `searchQueries` | array | No¹ | — | Product search terms on Back Market for the selected country. |
| `startUrls` | array | No¹ | — | Back Market search, category, or product URLs. Country comes from the hostname. |
| `country` | string | No | `DE` | Country for search queries: DE, AT, AU, BE, ES, FI, FR, GB, GR, IE, IT, JP, NL, PT, SE, SK, US. |
| `maxItems` | integer | No | `0` | Maximum products across all inputs (`0` = unlimited). |
| `includeProductDetails` | boolean | No | `false` | Fetch description, specifications, variants, and images. |
| `includeReviews` | boolean | No | `false` | Fetch customer reviews per product. |
| `maxReviews` | integer | No | `10` | Maximum reviews per product when reviews are enabled (`0` = all). |
| `detailConcurrency` | integer | No | `5` | Parallel workers for details and reviews (1–15). |
| `proxyConfiguration` | object | No | residential | Proxy settings. Residential proxy is recommended. |

¹ At least one of `searchQueries` or `startUrls` is required.

#### Can I mix search queries and URLs?

Yes. When both are set, the Actor processes search queries and start URLs in the same run.

### Output example

```json
{
  "productId": "12d2e039-0c01-4db9-ba49-69ab1a0eb4e8",
  "listingId": "be8a0fd7-1370-4b13-9b81-4a4abc4d9d2f",
  "name": "iPhone 16 Pro 128GB - Titan Schwarz - Ohne Vertrag",
  "model": "iPhone 16 Pro",
  "brand": "apple",
  "color": "Titan Schwarz",
  "url": "https://www.backmarket.de/de-de/p/iphone-16-pro",
  "price": 630.0,
  "formattedPrice": "630,00 €",
  "originalPrice": 1199.0,
  "currency": "EUR",
  "grade": "Gut",
  "rating": 4.51,
  "reviewCount": 15817,
  "countryCode": "DE",
  "sourceType": "search",
  "sourceQuery": "iphone"
}
```

### How much does it cost to scrape Back Market?

Billing is pay-per-event. A one-time **Actor Start** fee of **$0.00005** applies per run.

| Event | When it is charged | Price |
|---|---|---|
| Product scraped | Each product row written to the dataset | **$1.50 per 1,000** |
| Product Details | Each product when `includeProductDetails` is on | **$1.50 per 1,000** |
| Review | Each review when `includeReviews` is on | **$1.50 per 1,000** |

A listing-only run of 1,000 products costs about **$1.50** plus Actor Start. Adding details on every product and 10 reviews each adds about **$16.50** more plus Actor Start. Apify plan discounts may reduce these prices. Platform compute and proxy usage are billed separately on your Apify plan.

### Reliability and responsible use

- **Residential proxy recommended** — Default input uses Apify residential proxies for Back Market runs.
- **Conditional fields** — Specifications, variants, and reviews appear only when the corresponding toggles succeed.
- **Public data** — The Actor collects publicly visible product and review information from Back Market.
- **User responsibility** — Use collected data in line with applicable laws and Back Market terms.

### Frequently asked questions

#### Can I scrape Back Market in multiple countries?

Yes. Use `country` with search queries, or paste country-specific Back Market URLs in `startUrls`. Supported countries include DE, FR, GB, US, and 13 others.

#### Can I schedule Back Market Scraper to run automatically?

Yes. Create an Apify schedule on a saved task with your search terms, country, and enrichment toggles.

#### What counts as one result?

Each product written to the dataset counts as one **Product scraped** event. Details and reviews add separate events when enabled.

#### Why are specifications or reviews missing?

Specifications appear only when **Include Product Details** is on. Reviews appear only when **Include Reviews** is on and Back Market publishes them for that product.

#### How do I avoid duplicate records?

Within one run, products are unique by `productId`. Across runs the Actor appends results. Deduplicate user-side against `productId` when combining datasets.

#### Do I need a proxy?

Residential proxy is recommended for reliable runs on Apify Cloud. The default input enables Apify residential proxies.

### Related Scraptivo automations

- [Autotrader Scraper](https://apify.com/scraptivo/autotrader-scraper) — UK vehicle listings
- [CarMax Scraper](https://apify.com/scraptivo/carmax-scraper) — US used-car listings
- [Cars Scraper](https://apify.com/scraptivo/cars-scraper) — Cars.com vehicle listings
- [Amazon Product Scraper](https://apify.com/scraptivo/amazon-product-scraper) — Amazon product listings
- [eBay Product Scraper](https://apify.com/scraptivo/ebay-scraper) — eBay product listings

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

## `searchQueries` (type: `array`):

Product search terms to look up on Back Market (e.g. "iphone 16", "macbook air"). Uses the selected country. Combined with Start URLs when both are set.

## `startUrls` (type: `array`):

Back Market search, category, or product page URLs, e.g. https://www.backmarket.de/de-de/search?q=iphone, https://www.backmarket.at/de-at/l/smartphones/6c290010-c0c2-47a4-b68a-ac2ec2b64dca, or https://www.backmarket.de/de-de/p/iphone-16-pro. The country is taken from the URL host.

## `country` (type: `string`):

Back Market country used for search queries. Ignored for start URLs, which use the country from the hostname. Default is Germany.

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

Maximum number of products to scrape across all queries and URLs (0 = unlimited).

## `includeProductDetails` (type: `boolean`):

When enabled, fetch full product details for each item (description, specifications, images, variants). Charged as the product-details event in addition to each product.

## `includeReviews` (type: `boolean`):

When enabled, fetch customer reviews for each product. Charged as the product-reviews event once per review, in addition to each product.

## `maxReviews` (type: `integer`):

Maximum number of reviews to collect per product when Include Product Reviews is enabled (0 = all available reviews).

## `detailConcurrency` (type: `integer`):

How many products to enrich in parallel when product details or reviews are enabled. Each worker uses a rotated residential proxy.

## `proxyConfiguration` (type: `object`):

Proxy settings. Apify Residential proxies are recommended for reliable Back Market access.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone"
  ],
  "startUrls": [
    {
      "url": "https://www.backmarket.de/de-de/search?q=iphone"
    }
  ],
  "country": "DE",
  "maxItems": 10,
  "includeProductDetails": false,
  "includeReviews": false,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing scraped Back Market products

## `runStats` (type: `string`):

Aggregate scrape statistics for this run

# 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 = {
    "searchQueries": [
        "iphone"
    ],
    "startUrls": [
        {
            "url": "https://www.backmarket.de/de-de/search?q=iphone"
        }
    ],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/backmarket-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 = {
    "searchQueries": ["iphone"],
    "startUrls": [{ "url": "https://www.backmarket.de/de-de/search?q=iphone" }],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "iphone"
  ],
  "startUrls": [
    {
      "url": "https://www.backmarket.de/de-de/search?q=iphone"
    }
  ],
  "maxItems": 10,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/backmarket-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/backmarket-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5kSf0cLLtwccq3IQP/builds/se5MhscMH1PV6X7Ti/openapi.json