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

Extract public job listings from The Muse by category, location, company, level, and keywords. Export titles, companies, locations, links, and descriptions.

- **URL**: https://apify.com/fetch\_cat/the-muse-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 item extracteds

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

Scrape public job listings from The Muse into clean, export-ready datasets. Filter by keywords, locations, companies, job categories, seniority levels, date, page range, and result limit.

### What does The Muse Jobs Scraper do?

The Muse Jobs Scraper collects public job listings from The Muse and saves each matching job as a structured dataset item. It is built for repeatable job-market monitoring, recruiting research, sales prospecting, and competitive hiring analysis.

You can use it to answer questions such as:

- 💼 Which companies are hiring remote software engineers right now?
- 📍 What roles are open in a specific city or region?
- 🏢 Which The Muse employers are expanding a department?
- 📈 How many new jobs match a category and seniority level?
- 🔎 What job descriptions mention a target keyword or technology?

### Who is it for?

Recruiters can monitor roles by category, company, location, and seniority.

Job aggregators can collect public listings for indexing and enrichment workflows.

Labor-market analysts can track demand by role, category, geography, and employer.

Sales teams can identify companies currently hiring for relevant departments.

Job seekers and career coaches can build curated job lists for specific personas.

### Why use this scraper?

The Muse is a useful source of employer-branded job listings, company names, role titles, levels, categories, and application links. This actor turns those listings into structured data that can be exported to CSV, JSON, Excel, Google Sheets, BI tools, CRMs, or automation workflows.

### Common use cases

- Build a remote jobs feed
- Monitor hiring at target accounts
- Track category-level hiring trends
- Find companies hiring for specific skills
- Collect application URLs for job aggregation
- Compare job descriptions across companies
- Enrich recruiting dashboards with public job data

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Keywords | `keywords` | array, default `["engineer"]` | Optional words to match in the job title, company, location, category, level, or job description. Matching is applied after The Muse returns jobs. |
| Locations | `locations` | array, default `["Remote"]` | The Muse location names, for example Remote, New York, NY, London, United Kingdom, or Flexible / Remote. |
| Companies | `companies` | array | Company names to filter by, for example SpaceX, Optum, or Atlassian. Leave empty to search all companies. |
| Job categories | `categories` | array, default `["Software Engineering"]` | The Muse job categories, for example Software Engineering, Data and Analytics, Sales, or Marketing. |
| Seniority levels | `levels` | array | The Muse levels, for example Entry Level, Mid Level, Senior Level, or Management. |
| Maximum jobs | `maxItems` | integer, default `50` | Maximum number of matching job listings to save. |
| Maximum pages | `pageLimit` | integer, default `5` | Maximum The Muse result pages to scan. Each page can contain up to 20 jobs before keyword/date filtering. |
| Start page | `pageStart` | integer, default `1` | Start scraping from this The Muse result page. |
| Published after date | `dateFrom` | string | Optional ISO date. Jobs published before this date are skipped, for example 2026-01-01. |
| Proxy configuration | `proxyConfiguration` | object, default `{"useApifyProxy":true}` | Optional Apify proxy settings. Keep enabled for reliable cloud runs; disable only if you know direct requests work for your environment. |

### Output fields

| JSON key | Label | Type | Description |
| --- | --- | --- | --- |
| `id` | Id | number | Output field for id. |
| `title` | Title | string | Output field for title. |
| `companyName` | CompanyName | string / null | Output field for companyname. |
| `companyId` | CompanyId | number / null | Output field for companyid. |
| `companyShortName` | CompanyShortName | string / null | Output field for companyshortname. |
| `locations` | Locations | array | Output field for locations. |
| `categories` | Categories | array | Output field for categories. |
| `levels` | Levels | array | Output field for levels. |
| `tags` | Tags | array | Output field for tags. |
| `publicationDate` | PublicationDate | string / null | Output field for publicationdate. |
| `type` | Type | string / null | Output field for type. |
| `shortName` | ShortName | string / null | Output field for shortname. |
| `modelType` | ModelType | string / null | Output field for modeltype. |
| `descriptionHtml` | DescriptionHtml | string / null | Output field for descriptionhtml. |
| `descriptionText` | DescriptionText | string / null | Output field for descriptiontext. |
| `applyUrl` | ApplyUrl | string / null | Output field for applyurl. |
| `jobUrl` | JobUrl | string / null | Output field for joburl. |
| `sourcePage` | SourcePage | number | Output field for sourcepage. |
| `scrapedAt` | ScrapedAt | string | Output field for scrapedat. |

### Pricing

This Actor uses pay-per-event pricing configured in `.actor/actor.json`.

| Event | Price | Charged when |
| --- | --- | --- |
| Start (`start`) | $0.005 per event | One-time fee per run |
| Job saved (`item`) | $0.000042 per event, about $0.042 per 1,000 events | Per The Muse job listing saved to the dataset |
### Input overview

The actor supports these inputs:

- `keywords` — words to match in titles, companies, locations, categories, levels, or descriptions
- `locations` — location names such as `Remote`, `New York, NY`, or `Flexible / Remote`
- `companies` — company names such as `SpaceX` or `Optum`
- `categories` — categories such as `Software Engineering` or `Sales`
- `levels` — levels such as `Entry Level`, `Mid Level`, or `Senior Level`
- `maxItems` — maximum jobs to save
- `pageLimit` — maximum results pages to scan
- `pageStart` — starting result page
- `dateFrom` — optional minimum publication date
- `proxyConfiguration` — optional advanced proxy settings

### Ready-to-run examples

- [The Muse Python Job Description Search](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples/the-muse-python-job-description-search)
- [The Muse Target Company Jobs](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples/the-muse-target-company-jobs)
- [The Muse Senior Data Analytics Jobs](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples/the-muse-senior-data-analytics-jobs)
- [The Muse Entry Level Marketing Jobs](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples/the-muse-entry-level-marketing-jobs)
- [The Muse Remote Software Engineering Jobs](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples/the-muse-remote-software-engineering-jobs)

[View all ready-to-run examples](https://apify.com/fetch_cat/the-muse-jobs-scraper/examples)

### Example input

```json
{
  "keywords": ["engineer"],
  "locations": ["Remote"],
  "categories": ["Software Engineering"],
  "maxItems": 25,
  "pageLimit": 3,
  "pageStart": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Input tips

Use The Muse wording for best results. For example, try `Flexible / Remote` if `Remote` is too broad or too narrow.

Use `companies` when tracking specific employers.

Use `categories` and `levels` together when you need focused role lists.

Use `keywords` when the target term may appear inside the title or description rather than in a site filter.

Increase `pageLimit` when keyword filtering is strict because the actor may need to scan more source jobs to find enough matches.

### Output data

Each job listing can include:

| Field | Description |
| --- | --- |
| `id` | The Muse job identifier |
| `title` | Job title |
| `companyName` | Company name |
| `companyId` | The Muse company identifier |
| `companyShortName` | Company slug when available |
| `locations` | Job locations |
| `categories` | Job categories |
| `levels` | Seniority levels |
| `tags` | Tags returned for the listing |
| `publicationDate` | Public posting timestamp |
| `type` | Job type returned by The Muse |
| `shortName` | Job slug |
| `modelType` | Source model type |
| `descriptionHtml` | Original public job description HTML |
| `descriptionText` | Clean text description |
| `applyUrl` | Application or landing page URL |
| `jobUrl` | Public job URL |
| `sourcePage` | Result page where the job was found |
| `scrapedAt` | Scrape timestamp |

### Example output

```json
{
  "id": 21200162,
  "title": "Supplier Development Engineer, Mechanical (Starship)",
  "companyName": "SpaceX",
  "companyId": 15000190,
  "companyShortName": "spacex",
  "locations": ["El Segundo, CA"],
  "categories": ["Software Engineering"],
  "levels": ["Mid Level"],
  "tags": [],
  "publicationDate": "2026-06-26T18:34:43Z",
  "type": "external",
  "shortName": "supplier-development-engineer-mechanical-starship-c2f42a",
  "modelType": "jobs",
  "descriptionText": "SpaceX was founded under the belief...",
  "applyUrl": "https://www.themuse.com/jobs/spacex/...",
  "jobUrl": "https://www.themuse.com/jobs/spacex/...",
  "sourcePage": 1,
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add one or more filters.
3. Set `maxItems` to a safe first-run value.
4. Click **Start**.
5. Download results from the Dataset tab.

### How to export data

After the run finishes, open the dataset and export results as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

You can also fetch the dataset through the Apify API for automated workflows.

### API usage

Run The Muse Jobs Scraper from your own code with the Apify API.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "keywords": [
    "engineer"
  ],
  "locations": [
    "Remote"
  ],
  "companies": [],
  "categories": [
    "Software Engineering"
  ],
  "levels": []
};

const run = await client.actor('fetch_cat/the-muse-jobs-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/the-muse-jobs-scraper").call(run_input={
  "keywords": [
    "engineer"
  ],
  "locations": [
    "Remote"
  ],
  "companies": [],
  "categories": [
    "Software Engineering"
  ],
  "levels": []
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~the-muse-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["engineer"],"locations":["Remote"],"companies":[],"categories":["Software Engineering"],"levels":[]}'
```

### Use with AI agents via MCP

The Muse Jobs Scraper can be used by AI assistants through the hosted Apify MCP server.

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/the-muse-jobs-scraper"
```

**Claude Desktop, Cursor, or VS Code JSON config**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/the-muse-jobs-scraper"
    }
  }
}
```

**Example prompts**

- "Run The Muse Jobs Scraper with this input JSON and summarize the dataset."
- "Export the latest The Muse Jobs Scraper results to a table I can review."
- "Schedule this Actor for monitoring and tell me what changed between runs."

### Integrations

Use this actor with:

- Google Sheets for recruiting trackers
- Airtable for job board workflows
- Notion for curated job lists
- Slack alerts for new matching roles
- CRM enrichment for hiring-signal workflows
- BI dashboards for labor-market analysis
- Zapier or Make scenarios through Apify integrations

### Data quality notes

The actor saves public job fields as returned by the source. Some jobs may have multiple locations, multiple levels, or long HTML descriptions. Some fields can be empty if the source listing does not provide them.

Keyword filtering is intentionally broad: it checks several text fields so users can discover jobs where the keyword appears outside the title.

### Limits and pagination

The source returns paginated job listings. The actor stops when it reaches `maxItems`, reaches `pageLimit`, finds no more jobs, or reaches the available page count.

For narrow keyword searches, increase `pageLimit` because many scanned jobs may not match the keyword filter.

### Troubleshooting

If you get fewer jobs than expected, try these checks:

- Remove one filter and run again
- Increase `pageLimit`
- Check spelling and capitalization of company or category names
- Try a broader location such as `Remote`
- Lower keyword specificity

If a run finishes with no items, the selected filter combination may not have matching public listings.

### Best practices

Start with a small run before scaling.

Save working inputs as Apify tasks for recurring monitoring.

Use specific company lists for account-based workflows.

Use date filters when you only need recent postings.

Export `descriptionText` for NLP analysis and `descriptionHtml` when formatting matters.

### Legality and responsible use

This actor collects publicly available job listing data. Make sure your use complies with applicable laws, The Muse terms, privacy rules, and your internal data policies. Do not use scraped data for discriminatory hiring, spam, or unlawful profiling.

### FAQ

#### Can I scrape remote jobs only?

Yes. Add `Remote` or `Flexible / Remote` to `locations`, then set a suitable `maxItems` value.

#### Can I track specific companies?

Yes. Add company names in the `companies` input. You can provide one company or a list of companies.

#### Can I filter by seniority?

Yes. Use `levels` such as `Entry Level`, `Mid Level`, `Senior Level`, or other level names used by The Muse.

#### Does the actor return apply links?

Yes. `applyUrl` and `jobUrl` contain the public landing page URL when The Muse provides it.

#### Why are there no results for my category?

The selected category may have few current jobs, or the exact category wording may differ. Try a broader category or remove the category filter for discovery.

### Related actors

- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper)
- [ATS Jobs Scraper for 6 ATS Sources](https://apify.com/fetch_cat/ats-jobs-scraper)
- [Built In Jobs Scraper](https://apify.com/fetch_cat/builtin-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper)
- [Remote.com Jobs Scraper](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper)

### Support

Report bugs, wrong output, blocked runs, or missing fields from the Actor page. Include the Apify run ID or run URL, your input JSON, what you expected, what the Actor returned, and one reproducible public URL so the issue can be tested quickly.

#### 0.1

- Initial version with configurable inputs and structured The Muse Jobs results.

# Actor input Schema

## `keywords` (type: `array`):

Optional words to match in the job title, company, location, category, level, or job description. Matching is applied after The Muse returns jobs.

## `locations` (type: `array`):

The Muse location names, for example Remote, New York, NY, London, United Kingdom, or Flexible / Remote.

## `companies` (type: `array`):

Company names to filter by, for example SpaceX, Optum, or Atlassian. Leave empty to search all companies.

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

The Muse job categories, for example Software Engineering, Data and Analytics, Sales, or Marketing.

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

The Muse levels, for example Entry Level, Mid Level, Senior Level, or Management.

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

Maximum number of matching job listings to save.

## `pageLimit` (type: `integer`):

Maximum The Muse result pages to scan. Each page can contain up to 20 jobs before keyword/date filtering.

## `pageStart` (type: `integer`):

Start scraping from this The Muse result page.

## `dateFrom` (type: `string`):

Optional ISO date. Jobs published before this date are skipped, for example 2026-01-01.

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

Optional Apify proxy settings. Keep enabled for reliable cloud runs; disable only if you know direct requests work for your environment.

## Actor input object example

```json
{
  "keywords": [
    "engineer"
  ],
  "locations": [
    "Remote"
  ],
  "categories": [
    "Software Engineering"
  ],
  "maxItems": 20,
  "pageLimit": 3,
  "pageStart": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "keywords": [
        "engineer"
    ],
    "locations": [
        "Remote"
    ],
    "categories": [
        "Software Engineering"
    ],
    "maxItems": 20,
    "pageLimit": 3,
    "pageStart": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "keywords": ["engineer"],
    "locations": ["Remote"],
    "categories": ["Software Engineering"],
    "maxItems": 20,
    "pageLimit": 3,
    "pageStart": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "keywords": [
    "engineer"
  ],
  "locations": [
    "Remote"
  ],
  "categories": [
    "Software Engineering"
  ],
  "maxItems": 20,
  "pageLimit": 3,
  "pageStart": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fetch_cat/the-muse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Muse Jobs Scraper",
        "description": "Extract public job listings from The Muse by category, location, company, level, and keywords. Export titles, companies, locations, links, and descriptions.",
        "version": "0.1",
        "x-build-id": "8MjHuKdappkNPZrBm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~the-muse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~the-muse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~the-muse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional words to match in the job title, company, location, category, level, or job description. Matching is applied after The Muse returns jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "The Muse location names, for example Remote, New York, NY, London, United Kingdom, or Flexible / Remote.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Company names to filter by, for example SpaceX, Optum, or Atlassian. Leave empty to search all companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Job categories",
                        "type": "array",
                        "description": "The Muse job categories, for example Software Engineering, Data and Analytics, Sales, or Marketing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "levels": {
                        "title": "Seniority levels",
                        "type": "array",
                        "description": "The Muse levels, for example Entry Level, Mid Level, Senior Level, or Management.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching job listings to save.",
                        "default": 50
                    },
                    "pageLimit": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum The Muse result pages to scan. Each page can contain up to 20 jobs before keyword/date filtering.",
                        "default": 5
                    },
                    "pageStart": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Start scraping from this The Muse result page.",
                        "default": 1
                    },
                    "dateFrom": {
                        "title": "Published after date",
                        "type": "string",
                        "description": "Optional ISO date. Jobs published before this date are skipped, for example 2026-01-01."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Keep enabled for reliable cloud runs; disable only if you know direct requests work for your environment."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```