# Themuse Job Scraper (`shahidirfan/themuse-job-scraper`) Actor

Extract job listings from The Muse with structured, reliable data for recruitment research, job aggregation, market analysis, and career platforms. Scrape job titles, companies, locations, descriptions, job URLs, and other key details at scale with flexible search inputs.

- **URL**: https://apify.com/shahidirfan/themuse-job-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Jobs, Developer tools, Other
- **Stats:** 10 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does TheMuse Job Scraper do?

TheMuse Job Scraper collects public job listings from TheMuse.com and saves each result as a structured dataset item. Enter a keyword, location, and optional posting-date filter, or provide The Muse search and job URLs directly. Each record includes the job title, company, locations, categories, career levels, tags, publication date, source links, and full description text when available.

This TheMuse jobs scraper is useful for recruiting research, hiring intelligence, job-board aggregation, labor-market analysis, and recurring monitoring of roles published on The Muse.

### Why use TheMuse Job Scraper?

- **Targeted job searches** - Filter listings by keyword, location, and posting date.
- **Direct URL support** - Start with a The Muse search URL, public job-search URL, or individual public job URL.
- **Detailed job records** - Get descriptions, company information, locations, categories, levels, tags, dates, and source references in one dataset.
- **Controlled collection size** - Set both a maximum number of jobs and a pagination limit for predictable runs.
- **Research-ready exports** - Download results as JSON, CSV, Excel, XML, or other formats available in Apify datasets.
- **Repeatable workflows** - Schedule runs, connect webhooks, or access completed datasets through the Apify API.

### What data can you extract from TheMuse.com?

Each dataset item represents one job listing. The output combines the main listing data with source objects and search-result metadata.

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Job title. |
| `job_id` | Number | Unique The Muse job identifier. |
| `company` | String | Employer name. |
| `company_id` | Number | Employer identifier when available. |
| `company_short_name` | String | Company URL slug. |
| `company_data` | Object | Source company information, such as ID, name, and slug. |
| `location` | String | Combined primary location text. |
| `locations` | Array | All published job locations. |
| `location_count` | Number | Number of locations in `locations`. |
| `location_objects` | Array | Source location objects. |
| `job_category` | String | Combined primary category text. |
| `categories` | Array | Job category names. |
| `category_count` | Number | Number of categories in `categories`. |
| `category_objects` | Array | Source category objects. |
| `job_type` | String | Employment type, such as full time or part time. |
| `levels` | Array | Career level labels. |
| `level_short_names` | Array | Short career-level labels. |
| `level_objects` | Array | Source career-level objects. |
| `tags` | Array | Job tags published by The Muse. |
| `tag_objects` | Array | Source tag objects. |
| `publication_date` | String | Publication timestamp in ISO 8601 format. |
| `date_posted` | String | Same posting timestamp in a convenient field. |
| `url` | String | Public The Muse job-page URL. |
| `landing_page` | String | Source landing-page URL. |
| `api_url` | String | Public source URL for the job record. |
| `description_text` | String | Plain-text job description. |
| `description_html` | String | Formatted description when available. |
| `description_length` | Number | Character count of `description_text`. |
| `refs` | Object | Source reference links. |
| `slug` | String | URL-friendly job name. |
| `source` | String | Source label for the record. |
| `api_model_type` | String | Source model type. |
| `api_page` | Number | Search-results page where the job was found. |
| `api_page_count` | Number | Total pages reported for the search. |
| `api_total_results` | Number | Total matching jobs reported for the search. |
| `search_took_ms` | Number | Search duration reported by the source. |
| `search_timed_out` | Boolean | Whether the source reported a search timeout. |

### How to use TheMuse Job Scraper

1. Open the Actor in Apify Console.
2. Enter a keyword and optional location, or add one or more The Muse URLs in `startUrls`.
3. Select a posting-date range if you only need recent jobs.
4. Set `maxItems` and, for larger searches, `maxPages`.
5. Start the run and review the dataset preview.
6. Download the results or connect the dataset to your recruiting, research, or monitoring workflow.

With no filters, the Actor collects the available results using the default limit of 20 jobs. A `maxItems` value of `0` means no item cap, while a `maxPages` value of `0` allows pagination to continue until no more results are returned.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | Array | No | `[]` | The Muse search URLs, public job-search URLs, or individual public job URLs. |
| `keyword` | String | No | `software engineer` | Job title, skill, or search term used to find listings. |
| `location` | String | No | - | City, region, country, or `Remote` filter. |
| `datePosted` | String | No | `""` | Posting-date filter: `last_7d`, `last_30d`, or `last_month`. Leave empty for all available dates. |
| `maxItems` | Integer | No | `20` | Maximum number of job records to save. Use `0` for unlimited collection. |
| `maxPages` | Integer | No | `0` | Maximum number of result pages to process. Use `0` to continue until results are exhausted or `maxItems` is reached. |
| `proxyConfiguration` | Object | No | `{"useApifyProxy": false}` | Optional Apify Proxy settings for request routing. |

### Output Data

The Actor writes one job record per dataset item. Empty fields can occur when a listing does not publish that information.

| Field group | Included data |
|-------------|---------------|
| Job identity | `job_id`, `title`, `slug`, `url`, `landing_page`, `api_url` |
| Employer | `company`, `company_id`, `company_short_name`, `company_data` |
| Location | `location`, `locations`, `location_count`, `location_objects` |
| Classification | `job_type`, `job_category`, `categories`, `category_count`, `category_objects`, `levels`, `level_short_names`, `level_objects`, `tags`, `tag_objects` |
| Description | `description_text`, `description_html`, `description_length` |
| Dates and search metadata | `publication_date`, `date_posted`, `api_page`, `api_page_count`, `api_total_results`, `search_took_ms`, `search_timed_out` |
| Source metadata | `source`, `api_model_type`, `refs` |

### Usage Examples

#### Basic Keyword Search

Collect software engineering jobs using the default location and page settings:

```json
{
  "keyword": "software engineer",
  "maxItems": 20
}
```

#### Location and Date Filter

Collect recent marketing jobs listed for remote work:

```json
{
  "keyword": "marketing manager",
  "location": "Remote",
  "datePosted": "last_7d",
  "maxItems": 100,
  "maxPages": 5
}
```

#### Search URLs and Direct Job URLs

Process several public The Muse URLs in one run. The list can contain search URLs and individual job detail URLs:

```json
{
  "startUrls": [
    "https://www.themuse.com/search/keyword/data_science",
    "https://www.themuse.com/search/location/remote",
    "https://www.themuse.com/api/public/jobs/20020349"
  ],
  "maxItems": 100,
  "maxPages": 5
}
```

#### Larger Scheduled Collection

Use a higher item and page limit for a recurring labor-market dataset:

```json
{
  "keyword": "data analyst",
  "location": "United States",
  "datePosted": "last_30d",
  "maxItems": 500,
  "maxPages": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Sample Output

The following example shows the main fields in one dataset item. Source objects and descriptions can vary by listing.

```json
{
  "source": "api",
  "api_model_type": "Job",
  "job_id": 20020349,
  "slug": "operations-manager-b547da",
  "title": "Operations Manager",
  "company": "CVS Health",
  "company_id": 12096,
  "company_short_name": "cvshealth",
  "location": "Greenville, SC",
  "locations": ["Greenville, SC"],
  "location_count": 1,
  "job_category": "Retail",
  "categories": ["Retail"],
  "category_count": 1,
  "job_type": "Full time",
  "levels": ["Senior Level"],
  "level_short_names": ["senior"],
  "tags": [],
  "publication_date": "2025-09-08T19:37:04Z",
  "date_posted": "2025-09-08T19:37:04Z",
  "url": "https://www.themuse.com/jobs/cvshealth/operations-manager-b547da",
  "landing_page": "https://www.themuse.com/jobs/cvshealth/operations-manager-b547da",
  "api_url": "https://www.themuse.com/api/public/jobs/20020349",
  "description_text": "Full job description...",
  "description_length": 2476,
  "api_page": 1,
  "api_page_count": 5,
  "api_total_results": 100,
  "search_took_ms": 42,
  "search_timed_out": false,
  "refs": {
    "landing_page": "https://www.themuse.com/jobs/cvshealth/operations-manager-b547da"
  }
}
```

### Tips for Best Results

- **Start with a focused term** - Use a specific title such as `software engineer`, `product manager`, or `data analyst` before trying broader terms.
- **Add a location when needed** - Use a city, region, country, or `Remote` to reduce unrelated results.
- **Test with a small limit** - Begin with 20 to 50 items, confirm the fields you need, then increase `maxItems`.
- **Control pagination** - Set `maxPages` when you want a predictable run size or when testing a broad search.
- **Use date filters for monitoring** - `last_7d` is useful for fresh listings, while `last_30d` and `last_month` provide wider coverage.
- **Review source links** - Use `url` or `landing_page` to open the original listing and confirm important details.
- **Expect source-dependent fields** - Salary, tags, levels, descriptions, and location details may be empty when The Muse does not publish them.

### Integrations and Export Formats

- **Google Sheets** - Review, sort, and share job datasets with a recruiting or research team.
- **Airtable** - Build a searchable table of companies, roles, locations, and posting dates.
- **Webhooks** - Send completed-run notifications or dataset records to another service.
- **Make and Zapier** - Trigger alerts, enrichment, classification, or reporting workflows.
- **Apify API** - Retrieve dataset items programmatically after a run.
- **JSON, CSV, Excel, and XML** - Download the dataset in a format suited to applications, spreadsheets, reporting, or system exchange.

### Frequently Asked Questions

#### Can I collect jobs without a keyword?

Yes. Leave `keyword` empty and use `location`, `startUrls`, or both. If no filters are provided, the Actor starts with the default collection settings.

#### Can I collect one specific job?

Yes. Add its public The Muse API detail URL, such as `https://www.themuse.com/api/public/jobs/20020349`, to `startUrls`.

#### Which date filters are supported?

The input supports `last_7d`, `last_30d`, and `last_month`. Leave `datePosted` empty when you want to keep listings regardless of publication date.

#### How many jobs can I collect?

You can collect up to the available matching results or the `maxItems` value, whichever comes first. Set `maxItems` to `0` for no item cap and use `maxPages` to limit pagination if required.

#### Why is a field empty?

A field can be empty when the source listing does not provide that information. Check several records before treating a missing value as a collection problem.

#### Can I run this Actor on a schedule?

Yes. Create a schedule in Apify Console to repeat a search daily, weekly, or at another interval, then export the new dataset or trigger a webhook.

#### Can I export the results to CSV or Excel?

Yes. Apify datasets can be downloaded as CSV, Excel, JSON, XML, and other supported formats.

#### Is it legal to collect The Muse job data?

Public data collection can be subject to website terms, applicable laws, and privacy rules. You are responsible for using the data lawfully, respecting The Muse requirements, and avoiding misuse of personal information.

### Related Actors

- [APEC Jobs Scraper](https://apify.com/shahidirfan/apec-jobs-scraper) - Collect structured job offers from the APEC employment platform.
- [LinkedIn Job Scraper](https://apify.com/shahidirfan/linkedin-job-scraper) - Search LinkedIn job listings by keyword, location, and posting period.
- [USA Jobs Scraper](https://apify.com/shahidirfan/usa-jobs-scraper) - Collect federal job listings with agency, salary, location, and application data.
- [Talent Job Scraper](https://apify.com/shahidirfan/talent-job-scraper) - Gather job postings from Talent.com for research and monitoring workflows.

### Support

For issues, feature requests, or questions about a run, use the Issues tab on the Actor page or contact the developer through Apify.

### Legal Notice

This Actor is intended for legitimate collection of publicly available job information. You are responsible for complying with The Muse Terms of Service, applicable laws, privacy requirements, and any restrictions that apply to your use of the collected data.

# Actor input Schema

## `startUrls` (type: `array`):

Optional list of TheMuse search URLs or public API URLs. API detail URLs like https://www.themuse.com/api/public/jobs/20020349 are supported.

## `keyword` (type: `string`):

Job search keyword (e.g., 'software engineer', 'marketing'). Used to construct API search parameters when startUrl is not provided.

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

Location filter for constructing search URLs (e.g., 'New York', 'Remote'). Leave empty for all locations.

## `datePosted` (type: `string`):

Date filter for TheMuse URLs. Examples: 'last\_7d', 'last\_30d', 'last\_month'. Leave empty for all dates.

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

Maximum number of jobs to collect. Set to 0 for unlimited (scrape until no more results).

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

Safety cap on pagination. Set to 0 to paginate until empty or maxItems is reached.

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

Apify Proxy configuration. Residential proxies recommended for high-volume or stealth mode.

## Actor input object example

```json
{
  "startUrls": [],
  "keyword": "software engineer",
  "datePosted": "",
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "software engineer",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/themuse-job-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 = {
    "keyword": "software engineer",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/themuse-job-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "software engineer",
  "maxItems": 20
}' |
apify call shahidirfan/themuse-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shahidirfan/themuse-job-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/98A9pVzRsVHYUgUYl/builds/zX1GrEIcmfv0Ac7F6/openapi.json