# Refurbed Scraper (`hennobit/refurbed-scraper`) Actor

Real-time REST API for refurbed across 24 countries. Search, filter by live category attributes, and fetch full product details instantly via Standby mode.

- **URL**: https://apify.com/hennobit/refurbed-scraper.md
- **Developed by:** [Henno](https://apify.com/hennobit) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 🔌 refurbed-scraper

A REST API for [refurbed](https://www.refurbed.com/), the refurbished-electronics marketplace, covering all **24 country storefronts** 🌍

This Actor runs in **Standby mode**:

- 🟢 always-on live server, no waiting for a run to finish
- ⚡ call an endpoint, get your answer back in the same request
- 🚫 no input schema or run config, every request is just a plain HTTP call with query params

### 🚀 Quick start

This Actor's Standby URL is:

```
https://hennobit--refurbed-scraper.apify.actor
```

(shown on this Actor's page under "This Actor uses Standby mode"). Call it directly:

```bash
curl "https://hennobit--refurbed-scraper.apify.actor/search?query=macbook&country=de&token=<APIFY_TOKEN>"
```

Every response is JSON:

- ✅ `{ "ok": true, ... }` on success
- ❌ `{ "ok": false, "error": { "status", "message" } }` on failure

### 🧭 Recommended workflow

1. 🌍 **`GET /countries`** → which of the 24 country codes to use
2. 🗂️ **`GET /categories?country=de`** → find the category ID (a real tree via `parentId`)
3. 🎛️ **`GET /category/filters?category=11&country=de`** → see which attributes that category can be filtered on *right now* (RAM, colour, processor, ...) and their current valid values
4. 🔎 **`GET /category?category=11&country=de&minRamSize=16&processor=Apple+M2`** → query using those filters, by name

No need to ever open refurbed.com in a browser to build a query. 🎉

### 📚 Endpoints

| Endpoint | What it does | Billing |
|---|---|---|
| 📄 `GET /product?url=` | Full detail for one product page (specs, description, seller, warranty, other configurations) | 1 `result` |
| 📄📄 `GET /products?urls=` | Same, for up to 20 URLs at once, fetched in parallel | 1 `result` per successful item |
| 🔎 `GET /search?query=` | Full-text search | 1 `result` per product returned |
| 🗂️ `GET /category?category=` | List products in a category, filterable by that category's own attributes | 1 `result` per product returned |
| 🌳 `GET /categories?country=` | Every category that country carries, as a tree (`id`, `name`, `parentId`) | 1 `lookup` |
| 🎛️ `GET /category/filters?category=&country=` | Live filter attributes for a category (name, type, current min/max or values) | 1 `lookup` |
| 🌍 `GET /countries` | The 24 supported country codes, names, domains, currencies | 1 `lookup` |

📖 Full parameter reference, request/response shapes and examples: see the **API** tab in the Apify Console for this Actor (interactive docs, generated straight from its schema).

#### 📄 `/product` and `/products`

```bash
curl "https://hennobit--refurbed-scraper.apify.actor/product?url=https://www.refurbed.de/p/apple-macbook-air-m1-2020/&token=<APIFY_TOKEN>"
curl "https://hennobit--refurbed-scraper.apify.actor/products?urls=https://www.refurbed.de/p/a/,https://www.refurbed.de/p/b/&token=<APIFY_TOKEN>"
```

- `specs` and `otherOptions` **keys** are normalized to camelCase English (`ramSize`, `processor`, `colour`, ...) regardless of `country`, so you get the same keys no matter which of the 24 sites you're querying 🌐
- the **values** behind those keys stay in the site's own local language, same as everywhere else in this API

#### 🔎 `/search` and 🗂️ `/category`

Both accept:

- `country`, `minPrice`, `maxPrice`
- `sortPrice` (`relevance` | `asc` | `desc`)
- `maxResults` (1–200, default 20)
- `showOtherOptions`
- `rawFilters` (advanced/manual escape hatch)

`/category` *also* accepts that category's own filter attributes **by name** (discovered via `/category/filters`) instead of hand-built `rawFilters` strings:

```bash
curl "https://hennobit--refurbed-scraper.apify.actor/category?category=11&country=de&minRamSize=16&maxRamSize=64&processor=Apple+M2&token=<APIFY_TOKEN>"
```

- 🔢 numeric attribute → `min<Name>` / `max<Name>`
- 🏷️ enum attribute → bare name plus one of its current values

**📖 Pagination:** results are capped per call, but the response carries `nextPage` and `hasMore` so you can keep going:

```bash
curl "https://hennobit--refurbed-scraper.apify.actor/search?query=iphone&maxResults=50&token=<APIFY_TOKEN>"               # -> nextPage: 4
curl "https://hennobit--refurbed-scraper.apify.actor/search?query=iphone&maxResults=50&page=4&token=<APIFY_TOKEN>"         # continues from there
```

⚠️ `page` is refurbed's own listing page, not a raw item offset. Always pass back the previous response's `nextPage` rather than incrementing it yourself.

### 💸 Pricing (Pay-Per-Event)

- **`result`** 💎: one per product actually returned, across `/product`, `/products`, `/search`, `/category`
- **`lookup`** 🔍: one per call to `/categories`, `/category/filters`, or `/countries`. These exist to help you build a cheap, precise `result` request, so they're priced far below it, though still metered.

Check the Actor's page in the Apify Store for current prices per event.

If your run's spending limit can't cover a full request:

- `/search` / `/category` / `/products` → return whatever was affordable, with `chargeLimitReached: true`, instead of failing
- `/product` and the lookup endpoints → `402` instead, since they're a single, indivisible unit

Either way, you're never billed for more than you actually get back. 🛡️

### 🕒 Data freshness

| What | Freshness |
|---|---|
| Product/listing data (`/product`, `/products`, `/search`, `/category`) | 🔴 always live |
| Filter attributes (`/category/filters`) | 🔴 always live; min/max ranges and stock levels change within hours |
| Category tree (`/categories`) | 🟡 refreshed periodically, not on every call (see `generatedAt` in the response) |
| `/countries` | 🟡 maintained by hand, not scraped live; a new country storefront won't show up here until this list is updated |

A brand-new or renamed category may take a little while to show up in `/categories`.

# Actor input Schema

## Actor input object example

```json
{}
```

# Actor output Schema

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("hennobit/refurbed-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("hennobit/refurbed-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 '{}' |
apify call hennobit/refurbed-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hennobit/refurbed-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/3gf5tdUNnoRwIzC3K/builds/AVwOrIaDi0ajrqvZt/openapi.json