# The Muse Jobs Scraper (`crawlerbros/the-muse-jobs-scraper`) Actor

Scrape The Muse job listings - 500,000+ jobs from top companies. Filter by category, level, location, or company. Fetch individual jobs by ID. Extracts title, company, category, level, locations, description, publication date, and application URL.

- **URL**: https://apify.com/crawlerbros/the-muse-jobs-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
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 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

## The Muse Jobs Scraper

Scrape job listings from [The Muse](https://www.themuse.com/) — a curated job board with 500,000+ positions from thousands of companies. Extract job titles, company details, categories, experience levels, locations, descriptions, and application URLs.

### What does it do?

This actor fetches job data from The Muse's public REST API. You can:

- **Search jobs** with filters for category, experience level, location, and company
- **Get specific jobs** by their numeric job ID

No authentication or API key required.

### Output

Each record contains:

| Field | Description |
|-------|-------------|
| `id` | Numeric job ID on The Muse |
| `name` | Job title |
| `contents` | Full job description (HTML) |
| `publicationDate` | ISO 8601 date when the job was published |
| `landingPage` | URL to apply on The Muse |
| `sourceUrl` | Same as landingPage |
| `category` | Job category (e.g. "Software Engineering") |
| `level` | Experience level (e.g. "Mid Level") |
| `locations` | Array of location strings |
| `tags` | Array of skill or topic tags |
| `company.id` | Numeric company ID |
| `company.name` | Company name |
| `company.slug` | Company URL slug |
| `companyName` | Denormalized company name |
| `shortName` | Job URL slug |
| `publicationDate` | When the job was posted |
| `recordType` | Always `"job"` |
| `scrapedAt` | ISO timestamp when this record was scraped |

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | select | `search` | `search` (browse with filters) or `getJob` (fetch by ID) |
| `category` | select | — | Job category filter |
| `level` | select | — | Experience level filter |
| `location` | text | — | City/region filter (e.g. "New York City, NY") |
| `company` | text | — | Company slug filter (e.g. "google") |
| `jobIds` | array | — | Numeric job IDs for `getJob` mode |
| `maxItems` | integer | 100 | Maximum records to emit |

#### Available categories

- Software Engineering
- Data and Analytics
- Healthcare
- Sales
- Retail
- Management
- Science and Engineering
- Accounting and Finance
- Customer Service
- Product Management
- Real Estate
- Social Services
- Marketing
- Design

#### Available experience levels

- Internship
- Entry Level
- Mid Level
- Senior Level

### Example runs

**Search for software engineering jobs in New York:**
```json
{
  "mode": "search",
  "category": "Software Engineering",
  "location": "New York City, NY",
  "maxItems": 50
}
````

**Search for entry-level data jobs:**

```json
{
  "mode": "search",
  "category": "Data and Analytics",
  "level": "Entry Level",
  "maxItems": 25
}
```

**Get specific jobs by ID:**

```json
{
  "mode": "getJob",
  "jobIds": [21764983, 21764984],
  "maxItems": 10
}
```

### Use cases

- **Job market research** — track hiring trends by category, level, or location
- **Company intelligence** — monitor which companies are actively hiring on The Muse
- **Recruitment pipelines** — aggregate listings for specific job functions or seniority levels
- **Data enrichment** — combine with other data sources to analyze hiring velocity

### FAQ

**Does this require an API key?**
No. The Muse's public job API requires no authentication.

**How many jobs can I scrape?**
The Muse has 500,000+ active listings. The `maxItems` parameter lets you cap the output. Maximum is 10,000 per run.

**Why don't keyword searches filter results?**
The Muse public API filters by structured fields (category, level, location, company) rather than free-text keyword search. Use the category and level selectors to narrow results.

**What's the difference between `location` and the company's office location?**
The `location` field reflects where The Muse lists the job geographically. Remote roles may appear under multiple city entries.

**How fresh is the data?**
The actor fetches live data from The Muse API on each run. Job listings are typically updated in real time.

# Actor input Schema

## `mode` (type: `string`):

Select what to fetch: search jobs with filters, or get specific jobs by ID.

## `category` (type: `string`):

Filter results to a specific job category.

## `level` (type: `string`):

Filter by experience level.

## `location` (type: `string`):

Filter by city or region (e.g. 'New York City, NY', 'San Francisco, CA', 'Remote'). Must match The Muse location names exactly.

## `company` (type: `string`):

Filter by company slug (e.g. 'google', 'microsoft', 'amazon'). Use the company short\_name from The Muse URL.

## `jobIds` (type: `array`):

List of The Muse job IDs to fetch individually. Only used in getJob mode.

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

Maximum number of job records to emit.

## Actor input object example

```json
{
  "mode": "search",
  "category": "",
  "level": "",
  "maxItems": 5
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset containing all scraped job listings from The Muse.

# 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 = {
    "mode": "search",
    "category": "",
    "level": "",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/the-muse-jobs-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 = {
    "mode": "search",
    "category": "",
    "level": "",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/the-muse-jobs-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 '{
  "mode": "search",
  "category": "",
  "level": "",
  "maxItems": 5
}' |
apify call crawlerbros/the-muse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Muse Jobs Scraper",
        "description": "Scrape The Muse job listings - 500,000+ jobs from top companies. Filter by category, level, location, or company. Fetch individual jobs by ID. Extracts title, company, category, level, locations, description, publication date, and application URL.",
        "version": "1.0",
        "x-build-id": "JQqpfRtyC575EfskS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~the-muse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-the-muse-jobs-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/crawlerbros~the-muse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-the-muse-jobs-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/crawlerbros~the-muse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-the-muse-jobs-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "getJob"
                        ],
                        "type": "string",
                        "description": "Select what to fetch: search jobs with filters, or get specific jobs by ID.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Software Engineering",
                            "Data and Analytics",
                            "Healthcare",
                            "Sales",
                            "Retail",
                            "Management",
                            "Science and Engineering",
                            "Accounting and Finance",
                            "Customer Service",
                            "Product Management",
                            "Real Estate",
                            "Social Services",
                            "Marketing",
                            "Design"
                        ],
                        "type": "string",
                        "description": "Filter results to a specific job category.",
                        "default": ""
                    },
                    "level": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "Internship",
                            "Entry Level",
                            "Mid Level",
                            "Senior Level"
                        ],
                        "type": "string",
                        "description": "Filter by experience level.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by city or region (e.g. 'New York City, NY', 'San Francisco, CA', 'Remote'). Must match The Muse location names exactly."
                    },
                    "company": {
                        "title": "Company slug",
                        "type": "string",
                        "description": "Filter by company slug (e.g. 'google', 'microsoft', 'amazon'). Use the company short_name from The Muse URL."
                    },
                    "jobIds": {
                        "title": "Job IDs (mode=getJob)",
                        "type": "array",
                        "description": "List of The Muse job IDs to fetch individually. Only used in getJob mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to emit.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
