# Ruby Lane Scraper - Antiques, Vintage & Art Listings (`lulzasaur/rubylane-scraper`) Actor

Scrape Ruby Lane (rubylane.com) antiques, vintage collectibles, art & jewelry listings by keyword. Extract title, price, shop/seller, category, brand, country of origin, image, and item URL. Great for dealers, resellers, appraisers, and collectibles market research.

- **URL**: https://apify.com/lulzasaur/rubylane-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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

## Ruby Lane Scraper

Scrape [Ruby Lane](https://www.rubylane.com) — the curated marketplace for antiques, vintage collectibles, art, and fine jewelry — by keyword. Get clean, structured listing data for dealers, resellers, appraisers, and collectibles market research.

### What it extracts

For each search result:

| Field | Description |
|-------|-------------|
| `title` | Item title |
| `price` | Numeric price (USD) |
| `currency` | Currency code |
| `shopName` | Ruby Lane shop / seller name |
| `shopId` / `itemId` | Ruby Lane identifiers |
| `isOffer` | Whether the listing accepts "Make Offer" |
| `image` | Primary item image URL |
| `url` | Item detail page URL |
| `searchQuery` | The query that produced the row |

With **Scrape Full Details** enabled, each item page adds: `category` (Google product taxonomy), `brand` / maker, `origin` (country of origin), `era`, `material`, `availability`, `shopUrl`, and `breadcrumb`.

### Input

```json
{
  "searchQueries": ["vintage watch", "antique vase"],
  "maxResults": 60,
  "scrapeDetails": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

- **searchQueries** — plain keywords or full Ruby Lane search URLs. Each produces its own result set.
- **maxResults** — cap per query (0 = unlimited, paginates until exhausted).
- **scrapeDetails** — visit each item page for richer fields (slower).
- **proxyConfiguration** — Ruby Lane uses a reCAPTCHA/BotD bot-detection challenge that flags datacenter IPs. **US residential proxies are recommended** for reliable results.

### Output

Each listing is one row in the dataset. Example:

```json
{
  "title": "1910 Illinois Pocket Watch – Lever-Set • 50mm • Supreme 10K Gold-Filled Case",
  "price": 395,
  "currency": "USD",
  "shopName": "Vintage Watches",
  "shopId": "853278",
  "itemId": "2367",
  "isOffer": true,
  "image": "https://cdn0.rubylane.com/_pod/item/853278/2367/...-520-812203577.webp",
  "url": "https://www.rubylane.com/item/853278-2367/1910-Illinois-Pocket-Watch-Lever",
  "searchQuery": "vintage watch",
  "scrapedAt": "2026-07-09T01:00:00.000Z"
}
```

### Notes

- Pricing is Pay Per Result — you are billed per listing returned to the dataset.
- Ruby Lane is JavaScript-gated; this actor drives a real browser to clear the site's challenge. Use residential proxies for best success rates.

# Actor input Schema

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

Searches to scrape. Use plain keywords (e.g. 'vintage watch', 'antique vase', 'art deco ring') or a full Ruby Lane search URL (e.g. 'https://www.rubylane.com/search?q=majolica'). Each query produces its own result set.

## `maxResults` (type: `integer`):

Maximum number of listings to scrape per search query. Set to 0 for unlimited (paginates until the site runs out of results).

## `scrapeDetails` (type: `boolean`):

If enabled, visits each item's detail page for richer fields (category, brand/maker, country of origin, availability, seller shop URL). Slower but more data. If disabled, scrapes only the search-result data (title, price, shop/seller, image, URL).

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

RECOMMENDED: Ruby Lane uses a reCAPTCHA/BotD bot-detection challenge that flags datacenter IPs. Use Apify residential proxies (RESIDENTIAL group, US) for this scraper to work reliably.

## Actor input object example

```json
{
  "searchQueries": [
    "vintage watch"
  ],
  "maxResults": 60,
  "scrapeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "vintage watch"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/rubylane-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": ["vintage watch"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/rubylane-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 '{
  "searchQueries": [
    "vintage watch"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call lulzasaur/rubylane-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/L03A86wRpKk5NRuPr/builds/accHJ4Wc8UdjSUcVP/openapi.json