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

Scrape job listings from The Muse - quality roles from established companies. Filter by keyword, category, seniority level and location. Paginates automatically. Built for recruiters and job aggregators.

- **URL**: https://apify.com/logiover/the-muse-jobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 22 total users, 5 monthly users, 97.4% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
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 — Company Jobs & Careers Data to JSON/CSV/Excel

![The Muse Jobs Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-doIx8SfjCK6ph7bE8-8FSsGhByOQ-channels4_profile.jpg)

Scrape **job listings from [The Muse](https://www.themuse.com)** — a popular US job board known for strong company-culture content and quality professional roles — straight from its official public API. This **The Muse jobs scraper** extracts job title, company, categories, seniority level, locations and apply URLs, and exports everything to JSON, CSV or Excel. **No login, no API key, no blocking.**

Filter by keyword, category, seniority level and location, and let the Actor auto-paginate the entire result set. Built for **scheduled, recurring use**, it keeps recruiters, sourcers and job aggregators supplied with an always-fresh feed of professional job openings.

### ✨ What this Actor does / Key features

- **Official The Muse API** — fast, reliable and fully paginated; no fragile HTML parsing.
- **Rich data per job** — title, company, categories, seniority levels, locations, job type, description, publication date and apply URL.
- **Keyword search** — free-text matching against title, company and description.
- **Category filter** — narrow to fields like `Engineering`, `Data Science`, `Marketing`, `Sales`, `Design`, `Accounting and Finance`.
- **Seniority filter** — target `Entry Level`, `Mid Level`, `Senior Level` or `Management` roles.
- **Location filter** — filter by location text such as `New York` or `Remote`.
- **Automatic pagination** — fetches ~20 jobs per page and crawls every page until your limits; set `maxJobs` and `maxPages` to `0` for everything.
- **Structured, export-ready output** — flat JSON records, ideal for JSON, CSV, Excel, ATS, CRM or BI tools.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `searchKeyword` | string | Free-text keyword matched against job title, company and description. Leave empty for all jobs. |
| `categories` | array | Filter by category, e.g. `Engineering`, `Data Science`, `Marketing`, `Sales`, `Accounting and Finance`, `Design`. Leave empty for all. |
| `levels` | array | Filter by seniority level, e.g. `Entry Level`, `Mid Level`, `Senior Level`, `Management`. Leave empty for all. |
| `location` | string | Filter by location text, e.g. `New York`, `Remote`. Leave empty for all. |
| `maxJobs` | integer | Maximum matching jobs to save. `0` = all. |
| `maxPages` | integer | Maximum API pages to fetch (~20 jobs per page). `0` = all. |

### 🚀 Example input

```json
{
  "categories": ["Software Engineering"],
  "levels": ["Senior Level"],
  "location": "Remote",
  "maxJobs": 0,
  "maxPages": 0
}
````

Search by keyword across all categories:

```json
{
  "searchKeyword": "product manager",
  "maxJobs": 300,
  "maxPages": 20
}
```

### 📦 Output

Each item in the dataset is one job listing from The Muse. Output is flat, structured JSON — easy to export to CSV or Excel or push into a database.

| Field | Description |
|-------|-------------|
| `jobId` | Unique identifier for the job on The Muse. |
| `title` | Job title. |
| `company` | Name of the hiring company. |
| `categories` | Array of categories the job belongs to (e.g. `Software Engineering`). |
| `levels` | Array of seniority levels for the role. |
| `locations` | Array of locations where the job is offered. |
| `jobType` | Type of job (e.g. full-time), where available. |
| `description` | Job description text. |
| `url` | Direct link to the job posting / apply page. |
| `publishedAt` | Publication date of the listing. |
| `scrapedAt` | ISO timestamp of when the record was scraped. |

#### Example output record

```json
{
  "jobId": "12345",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "categories": ["Software Engineering"],
  "levels": ["Senior Level"],
  "locations": ["New York, NY", "Remote"],
  "jobType": "full-time",
  "description": "We are looking for a Senior Software Engineer...",
  "url": "https://www.themuse.com/jobs/acmecorp/senior-software-engineer",
  "publishedAt": "2026-05-10T09:00:00Z",
  "scrapedAt": "2026-05-15T08:30:00.000Z"
}
```

### 💡 Use cases

- **Recruiters & sourcers** — maintain a fresh feed of professional roles filtered by category and seniority level.
- **Job boards & aggregators** — keep a curated jobs section automatically current with quality listings.
- **Market & hiring researchers** — track hiring trends by company, category and seniority over time.
- **Lead generation** — identify companies that are actively hiring for specific roles.
- **Talent-intelligence teams** — analyze the professional job market by location, category and level.

### ❓ Frequently Asked Questions

**Do I need a The Muse API key or login?**
No. The Actor uses The Muse's official public API and requires no API key, account or login.

**Is it legal to scrape The Muse?**
The Actor reads publicly available job listings via The Muse's official public API, which is intended for programmatic access. You are responsible for complying with The Muse's terms of service and for how you use the data.

**How many jobs can I get?**
The Actor auto-paginates the entire result set for your filters. Set `maxJobs` and `maxPages` to `0` to pull every available listing, or set smaller numbers for a faster, capped run.

**Can I filter by category, seniority or location?**
Yes. Use `categories`, `levels` and `location` together with the free-text `searchKeyword` to target exactly the roles you want. Leave any filter empty to include all values.

**How fast is it and how much does it cost?**
It runs as fast API requests and completes quickly even for large result sets. Cost depends only on the small amount of Apify compute used; there are no third-party fees.

**Can I schedule it to run automatically?**
Yes. Use the Apify Scheduler to run the Actor daily (or more often) for an always-fresh professional-jobs feed.

**What output formats are supported?**
Results are stored in an Apify dataset and can be exported to JSON, CSV, Excel or XML, or pulled via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to run daily for a continuously updated professional-jobs feed. Export results to JSON, CSV or Excel, pull them through the Apify API, or connect the dataset to Google Sheets, webhooks or your ATS / CRM for automated recruitment workflows.

# Actor input Schema

## `searchKeyword` (type: `string`):

Free-text keyword matched against title, company and description.

## `categories` (type: `array`):

Filter by category, e.g. 'Engineering', 'Data Science', 'Marketing', 'Sales', 'Accounting and Finance', 'Design'. Leave empty for all.

## `levels` (type: `array`):

Filter by level, e.g. 'Entry Level', 'Mid Level', 'Senior Level', 'Management'. Leave empty for all.

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

Filter by location text, e.g. 'New York', 'Remote'. Leave empty for all.

## `maxJobs` (type: `integer`):

Maximum matching jobs to save. 0 = all.

## `maxPages` (type: `integer`):

Maximum API pages to fetch (~20 jobs per page). 0 = all.

## Actor input object example

```json
{
  "searchKeyword": "",
  "categories": [],
  "levels": [],
  "location": "",
  "maxJobs": 100,
  "maxPages": 100000
}
```

# Actor output Schema

## `title` (type: `string`):

title

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

company

## `categories` (type: `string`):

categories

## `levels` (type: `string`):

levels

## `locations` (type: `string`):

locations

## `jobType` (type: `string`):

jobType

## `url` (type: `string`):

url

## `publishedAt` (type: `string`):

publishedAt

# 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 = {
    "categories": [],
    "levels": [],
    "maxJobs": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "categories": [],
    "levels": [],
    "maxJobs": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "categories": [],
  "levels": [],
  "maxJobs": 100
}' |
apify call logiover/the-muse-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/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 job listings from The Muse - quality roles from established companies. Filter by keyword, category, seniority level and location. Paginates automatically. Built for recruiters and job aggregators.",
        "version": "1.0",
        "x-build-id": "7l0EbcYpgk74Rzw5Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~the-muse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-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/logiover~the-muse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-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/logiover~the-muse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-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",
                "properties": {
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Free-text keyword matched against title, company and description.",
                        "default": ""
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by category, e.g. 'Engineering', 'Data Science', 'Marketing', 'Sales', 'Accounting and Finance', 'Design'. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "levels": {
                        "title": "Seniority Levels",
                        "type": "array",
                        "description": "Filter by level, e.g. 'Entry Level', 'Mid Level', 'Senior Level', 'Management'. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by location text, e.g. 'New York', 'Remote'. Leave empty for all.",
                        "default": ""
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum matching jobs to save. 0 = all."
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum API pages to fetch (~20 jobs per page). 0 = all.",
                        "default": 100000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
