# Mercor Scraper — AI Marketplace Job Listings (`studio-amba/mercor-scraper`) Actor

Scrape live contractor and expert gig listings from Mercor's AI talent marketplace (work.mercor.com): title, pay rate, category, location, commitment type and posted date. No login or cookies required.

- **URL**: https://apify.com/studio-amba/mercor-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result 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/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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Mercor Scraper

Extract live contractor and expert gig listings from [Mercor](https://work.mercor.com/explore), the AI-recruiting/talent marketplace that matches subject-matter experts, freelancers and knowledge workers to paid work for AI labs and their client companies (data labeling, model evaluation, occupation studies, expert interviews, and part-time or hourly contract roles). Get every live listing as clean structured JSON: title, hiring company (when disclosed), pay rate, category, location, commitment type and posted date.

No login. No cookies. No browser automation. The actor talks directly to Mercor's own public JSON API — the same endpoint the work.mercor.com website calls — so it is fast, cheap and stable.

### What this actor does

Mercor runs a live marketplace of paid gigs: AI training data annotation, expert evaluation of model outputs, one-off occupation surveys, and ongoing part-time/full-time contract roles across dozens of professional categories (law, medicine, finance, software engineering, data analysis, and more). This actor pulls the full current set of active listings in one call and lets you filter it down by keyword, category, commitment type, location and minimum pay rate — then returns one row per listing with:

- Listing title and full description
- Hiring company name (Mercor blinds the company on roughly 6 in 10 listings until a candidate applies — those come back as `null`, which is expected, not a scraping gap)
- Category ("listing domain" — e.g. Software Engineering, Law, Medicine, Data Analysis)
- Location and work arrangement (remote/onsite)
- Commitment type (hourly, part-time, full-time) and expected hours/week
- Pay rate range and frequency
- Whether the listing offers equity
- Eligible countries/regions, if the listing is geographically restricted
- Posted date and a direct, canonical listing URL

### Why use it

- **AI-labor market research** — track how many paid AI-training/expert gigs are live at any moment, and in which categories and price bands.
- **Rate benchmarking** — Mercor publishes hourly rates directly; use this to benchmark what AI labs are paying subject-matter experts by domain (law, medicine, finance, engineering).
- **Recruiting and sourcing intel** — see which client companies are hiring through Mercor and for what kind of work.
- **Lead generation for freelancers/agencies** — a live feed of open remote gigs filtered by category or minimum rate.
- **Competitive intelligence** — Mercor is one of the fastest-growing AI-recruiting marketplaces; this actor gives you a repeatable snapshot of its live listing volume and mix.

### How to scrape Mercor data

1. Open the actor and set a **Search Keyword** (for example `data engineer`, `legal`, `medicine` or leave the default). It matches against both the listing title and full description.
2. Optionally pick a **Category** (Listing Domain) such as Software Engineering, Law, Medicine or Data Analysis, or leave it on "All categories".
3. Optionally filter by **Commitment Type** (hourly / part-time / full-time), **Location** (e.g. `Remote`, `United States`) and **Minimum Pay Rate**.
4. Set **Max Results** to how many listings you want back.
5. Click **Start**.

The actor makes a single call to Mercor's `listings-explore-page` API, which returns every currently active listing (246 at the time this actor was built), then applies your filters client-side — Mercor's own API doesn't support server-side search or pagination parameters, so filtering happens in the actor for reliable, complete results. Export as JSON, CSV or Excel.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Keyword matched against title + description (case-insensitive). Default: `data`. |
| `listingDomain` | string | Filter by category (e.g. `Software Engineering`, `Law`, `Medicine`). Empty = all categories. |
| `commitment` | string | Filter by `hourly`, `part-time` or `full-time`. Empty = all. |
| `locationFilter` | string | Substring match on the location field (e.g. `Remote`, `United States`). Empty = all. |
| `minRate` | integer | Minimum pay rate (max of the listing's rate range must be ≥ this number). Default: `0` (no filter). |
| `maxResults` | integer | Maximum number of listings to return. Default: `50`. |
| `proxyConfiguration` | object | Apify proxy settings. Mercor's API has no anti-bot, so any setting (including none) works. |

#### Example input

```json
{
    "searchQuery": "data engineer",
    "listingDomain": "Data Analysis",
    "commitment": "",
    "locationFilter": "",
    "minRate": 0,
    "maxResults": 50
}
````

### Output

Each dataset item looks like this (real output from a live test run):

```json
{
    "listingId": "list_AAABn4eLz1zT1QqB0LtGSr92",
    "jobTitle": "Law Expert",
    "company": "Deeptune",
    "listingDomain": "Law",
    "location": "Remote",
    "workArrangement": "remote",
    "commitment": "hourly",
    "hoursPerWeek": 40,
    "salaryMin": 75,
    "salaryMax": 150,
    "salaryFrequency": "hourly",
    "salaryCurrency": "USD",
    "offersEquity": false,
    "eligibleLocations": ["USA"],
    "postedDate": "2026-07-22T01:58:35",
    "description": "## About the Role\n\nMercor is partnering with a leading AI lab to train frontier models on high-quality legal reasoning data...",
    "url": "https://work.mercor.com/jobs/list_AAABn4eLz1zT1QqB0LtGSr92",
    "scrapedAt": "2026-07-22T15:05:21.962Z"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Mercor's internal listing ID |
| `jobTitle` | string | Listing title |
| `company` | string | null | Hiring company name, or `null` on blind listings |
| `listingDomain` | string | Category (e.g. Software Engineering, Law, Medicine) |
| `location` | string | Location as listed (usually "Remote") |
| `workArrangement` | string | null | remote / onsite / hybrid |
| `commitment` | string | hourly / part-time / full-time |
| `hoursPerWeek` | number | null | Expected weekly hours, if specified |
| `salaryMin` | number | null | Minimum pay rate |
| `salaryMax` | number | null | Maximum pay rate |
| `salaryFrequency` | string | null | Pay rate frequency (usually "hourly") |
| `salaryCurrency` | string | Rate currency (USD unless otherwise stated) |
| `offersEquity` | boolean | Whether the listing offers equity |
| `eligibleLocations` | array | Country/region codes eligible to apply, if restricted |
| `postedDate` | string | ISO date the listing was posted |
| `description` | string | Full listing description (markdown source) |
| `url` | string | Canonical listing URL on work.mercor.com |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

### Cost estimate

This actor makes exactly one HTTP call per run (Mercor returns its entire live listing set in a single response), so runs are extremely cheap and fast — a full run over hundreds of listings typically finishes in a few seconds of actual compute. Exact cost depends on your Apify plan and the number of results you request.

### Limitations

- **Company names are blind on many listings.** Mercor hides the hiring company's identity on a large share of listings (roughly 6 in 10 at the time of writing) until a candidate applies — this is a Mercor product decision, not a scraping gap, and shows up as `company: null`.
- **No server-side filtering on Mercor's end.** Mercor's API always returns the full active listing set and ignores query parameters; this actor filters client-side, which is reliable but means the API call itself always fetches everything before your filters are applied.
- **Only currently active listings.** Mercor's API only exposes live listings, not historical or closed ones — run the actor on a schedule if you need a time series.
- **Rates are as published by Mercor**, not verified independently; a small number of listings omit a rate entirely (`salaryMin`/`salaryMax`: `null`).

### Related scrapers

Building a broader jobs dataset? These sibling actors follow the same clean-JSON, no-login approach:

- **NoFluffJobs Scraper** — European tech job listings with transparent salary ranges
- **Greenhouse Jobs Scraper** — job postings from any company's public Greenhouse career board
- **Xing Jobs Scraper** — DACH-region job listings (Germany, Austria, Switzerland)
- **Totaljobs Scraper** — UK job listings
- **Jobs.ch Scraper** — Swiss job listings in German, French and English

# Actor input Schema

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

Only return listings whose title or description contains this keyword (case-insensitive). Leave empty to return all live listings. Defaults to 'expert' if input is empty.

## `listingDomain` (type: `string`):

Filter by Mercor's listing category. Leave empty for all categories.

## `commitment` (type: `string`):

Filter by engagement type. Leave empty for all.

## `locationFilter` (type: `string`):

Only return listings whose location text contains this string (case-insensitive). Examples: 'Remote', 'United States', 'UK'. Leave empty for all locations.

## `minRate` (type: `integer`):

Only return listings with a maximum pay rate at or above this number (in the listing's own currency/frequency — Mercor rates are almost always USD/hourly). Leave at 0 for no filter.

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

Maximum number of listings to return.

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

Mercor's listings API (aws.api.mercor.com) is public with no anti-bot — any proxy configuration works, including none at all.

## Actor input object example

```json
{
  "searchQuery": "expert",
  "listingDomain": "",
  "commitment": "",
  "minRate": 0,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "expert",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/mercor-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": "expert",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/mercor-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": "expert",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/mercor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercor Scraper — AI Marketplace Job Listings",
        "description": "Scrape live contractor and expert gig listings from Mercor's AI talent marketplace (work.mercor.com): title, pay rate, category, location, commitment type and posted date. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "SyA8Uu30LUERa5xCi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~mercor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-mercor-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/studio-amba~mercor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-mercor-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/studio-amba~mercor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-mercor-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 Keyword",
                        "type": "string",
                        "description": "Only return listings whose title or description contains this keyword (case-insensitive). Leave empty to return all live listings. Defaults to 'expert' if input is empty."
                    },
                    "listingDomain": {
                        "title": "Category (Listing Domain)",
                        "enum": [
                            "",
                            "Business Operations",
                            "Language and Audio",
                            "Finance",
                            "Arts & Design",
                            "Life, Physical, and Social Science",
                            "Law",
                            "Data Analysis",
                            "Software Engineering",
                            "Medicine",
                            "Other Engineering",
                            "Humanities",
                            "Miscellaneous"
                        ],
                        "type": "string",
                        "description": "Filter by Mercor's listing category. Leave empty for all categories.",
                        "default": ""
                    },
                    "commitment": {
                        "title": "Commitment Type",
                        "enum": [
                            "",
                            "hourly",
                            "part-time",
                            "full-time"
                        ],
                        "type": "string",
                        "description": "Filter by engagement type. Leave empty for all.",
                        "default": ""
                    },
                    "locationFilter": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Only return listings whose location text contains this string (case-insensitive). Examples: 'Remote', 'United States', 'UK'. Leave empty for all locations."
                    },
                    "minRate": {
                        "title": "Minimum Pay Rate",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with a maximum pay rate at or above this number (in the listing's own currency/frequency — Mercor rates are almost always USD/hourly). Leave at 0 for no filter.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Mercor's listings API (aws.api.mercor.com) is public with no anti-bot — any proxy configuration works, including none at all.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
