# The Muse Jobs Scraper (`parseforge/themuse-jobs-scraper`) Actor

Export curated jobs and company profiles from The Muse. Search 500k+ openings across tech, marketing, design, sales, and more. Filter by category, location, and experience level. Pull title, company, location, salary hints, description, and apply links.

- **URL**: https://apify.com/parseforge/themuse-jobs-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result items

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 The Muse Jobs Scraper

> 🚀 **Export curated jobs and company profiles from The Muse in seconds.** Pull **500,000+ openings** across tech, marketing, design, sales, and more. No login, no manual paging, no broken descriptions.

> 🕒 **Last updated:** 2026-05-22 · **📊 18 fields** per record · **💼 500,000+ jobs** · **🏢 60,000+ employers** · **🗂️ 30 verified categories**

The **The Muse Jobs Scraper** exports curated job postings from The Muse and returns **18 fields per record**, including title, company, location, level, full HTML description, apply link, and posting date. The underlying catalog is one of the most heavily browsed early-career and mid-career job boards in North America, with editorial company profiles attached to every employer.

The catalog covers **30 verified categories, 4 seniority levels, and remote-friendly locations worldwide**. This Actor makes that catalog downloadable as CSV, Excel, JSON, or XML in under five minutes. All filters run on the source side, so you skip the paging and parsing entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Career sites, job aggregators, recruiters, talent intelligence teams, sourcers, career coaches, data journalists | Build a niche job board, enrich a sourcing pipeline, market mapping, competitor hiring trackers, weekly digest emails, talent supply analyses |

---

### 📋 What the The Muse Jobs Scraper does

Four filtering workflows in a single run:

- 🌍 **Worldwide pull.** Every active job in the catalog across all categories and levels.
- 🗂️ **Category filter.** Restrict to one of 30 verified job functions such as Software Engineering, Design and UX, or Sales.
- 🎚️ **Level filter.** Internship, Entry Level, Mid Level, or Senior Level.
- 🏢 **Company filter.** Limit results to a single employer using its display name.

Each record includes the job title, full company name and slug, primary category, all categories, all levels, an array of structured locations, posting date, plain-text description, full HTML description, and the direct apply link.

> 💡 **Why it matters:** curated boards filter out the noisiest listings before they reach you. Building a parser yourself means handling category drift, HTML cleanup, and refresh logic. This Actor skips that work and keeps the dataset fresh on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded jobs feed._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>category</td><td>string</td><td>""</td><td>One of 30 verified categories. Empty = all categories.</td></tr>
<tr><td>level</td><td>string</td><td>""</td><td>Internship, Entry Level, Mid Level, or Senior Level. Empty = all levels.</td></tr>
<tr><td>location</td><td>string</td><td>""</td><td>City and state or country, e.g. "New York, NY", "Remote".</td></tr>
<tr><td>company</td><td>string</td><td>""</td><td>Employer display name, e.g. "SpaceX", "Audible, Inc.".</td></tr>
</tbody>
</table>

**Example: 100 senior software engineering jobs.**

```json
{
    "maxItems": 100,
    "category": "Software Engineering",
    "level": "Senior Level"
}
````

**Example: every Audible role in New York.**

```json
{
    "maxItems": 200,
    "company": "Audible, Inc.",
    "location": "New York, NY"
}
```

> ⚠️ **Good to Know:** when a job lists multiple categories or levels, the `category` and `level` fields contain the primary value and the `categories` / `levels` arrays contain the full list. Use the arrays for downstream filtering when an opening spans multiple functions.

***

### 📊 Output

Each job record contains **18 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `jobId` | string | `"d4a1c2e0-1f3b-4a5e-9c6d-7e8f9a0b1c2d"` |
| 🏷️ `title` | string | `"Senior Software Engineer, Payments"` |
| 🏢 `companyName` | string | `"SpaceX"` |
| 🆔 `companyId` | string | `"4a9c5d6e-7f8b-4a1c-9e2d-3f4a5b6c7d8e"` |
| 🔗 `companyShortName` | string | `"spacex"` |
| 🗂️ `category` | string | `"Software Engineering"` |
| 🗂️ `categories` | array | `["Software Engineering", "Data and Analytics"]` |
| 🎚️ `level` | string | `"Senior Level"` |
| 🎚️ `levels` | array | `["Senior Level"]` |
| 📍 `locations` | array | `[{"name": "Hawthorne, CA"}]` |
| 📋 `jobType` | string | null | `"FULL_TIME"` |
| 📅 `publicationDate` | string | `"2026-05-20T17:42:31.000Z"` |
| 🔗 `shortName` | string | `"senior-software-engineer-payments-spacex"` |
| 📝 `description` | string | `"We are looking for a Senior Software Engineer..."` |
| 📝 `descriptionHtml` | string | `"<p>We are looking for a Senior Software Engineer...</p>"` |
| 🔗 `applyUrl` | string | `"https://www.themuse.com/jobs/spacex/senior-..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |
| ⚠️ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>💻 Senior software engineering role</strong></summary>

```json
{
    "jobId": "d4a1c2e0-1f3b-4a5e-9c6d-7e8f9a0b1c2d",
    "title": "Senior Software Engineer, Payments",
    "companyName": "SpaceX",
    "companyShortName": "spacex",
    "category": "Software Engineering",
    "categories": ["Software Engineering"],
    "level": "Senior Level",
    "levels": ["Senior Level"],
    "locations": [{"name": "Hawthorne, CA"}],
    "publicationDate": "2026-05-20T17:42:31.000Z",
    "applyUrl": "https://www.themuse.com/jobs/spacex/senior-software-engineer-payments",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🎧 Editorial / mid-level role</strong></summary>

```json
{
    "jobId": "8a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d",
    "title": "Senior Content Producer",
    "companyName": "Audible, Inc.",
    "companyShortName": "audible-inc",
    "category": "Media, PR, and Communications",
    "categories": ["Media, PR, and Communications"],
    "level": "Senior Level",
    "levels": ["Senior Level"],
    "locations": [{"name": "Newark, NJ"}],
    "publicationDate": "2026-05-19T13:08:14.000Z",
    "applyUrl": "https://www.themuse.com/jobs/audibleinc/senior-content-producer",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🌐 Remote design role</strong></summary>

```json
{
    "jobId": "1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d",
    "title": "Staff Product Designer",
    "companyName": "GitLab",
    "companyShortName": "gitlab",
    "category": "Design and UX",
    "categories": ["Design and UX"],
    "level": "Senior Level",
    "levels": ["Senior Level"],
    "locations": [{"name": "Remote"}],
    "publicationDate": "2026-05-18T09:21:00.000Z",
    "applyUrl": "https://www.themuse.com/jobs/gitlab/staff-product-designer",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 💼 | **Curated catalog.** 500,000+ jobs hand-categorized into 30 verified functions. |
| 🎯 | **Multi-filter combinations.** Category, level, location, and company filters compose freely in one run. |
| 📝 | **Full HTML descriptions.** Every record ships both clean plain text and the original rich HTML body. |
| 🔗 | **Direct apply links.** Send candidates straight to the source listing, no extra hop. |
| ⚡ | **Fast.** 10 jobs in under 5 seconds, 10,000 in under five minutes. |
| 🔁 | **Always fresh.** Every run hits the live catalog, so the dataset reflects current openings. |
| 🚫 | **No authentication.** Works with publicly listed jobs. No login or token needed. |

> 📊 Curated job data is the foundation of every modern talent dashboard, market map, and career discovery feature.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ The Muse Jobs Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **500,000+** curated jobs | **Live per run** | category, level, location, company | ⚡ 2 min |
| Manual browsing on themuse.com | Free | Small per session | Live | Limited UI filters | 🐢 Days |
| Aggregator data feeds | $500+/month | Mixed sources | Hourly | Many | ⏳ Hours |
| Building your own crawler | Engineering cost | Brittle | Breaks often | Custom | 🕒 Weeks |

Pick this Actor when you want curated coverage, structured filters, and zero pipeline upkeep.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the The Muse Jobs Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a category, level, location, or company, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🧲 Recruiters and sourcers

- Build a daily feed of senior software engineering roles
- Track openings at a target list of competitor companies
- Map remote-first hiring across categories
- Pre-fill candidate outreach with live job titles

</td>
<td width="50%" valign="top">

#### 🌐 Career sites and aggregators

- Power a niche board for a single category, e.g. design jobs
- Embed live openings into a community newsletter
- Cross-post curated roles to a Slack or Discord
- Refresh a marketplace listing page every morning

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Talent intelligence and analytics

- Hiring volume per category by week
- Senior vs entry-level mix at named employers
- Geographic distribution of remote openings
- Time-to-fill proxies using posting date deltas

</td>
<td width="50%" valign="top">

#### 🤖 AI and product teams

- Train resume-to-job matching models on real titles and descriptions
- Power autocomplete for company names with verified slugs
- Feed a search index with cleaned HTML descriptions
- Benchmark LLM job classification against the source category

</td>
</tr>
</table>

***

### 🔌 Automating The Muse Jobs Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep downstream job boards in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Labor-market studies on remote work adoption
- Sociology research on entry-level career pathways
- Coursework on text classification with real descriptions
- Time-series tracking of job titles in emerging fields

</td>
<td width="50%">

#### 🎨 Personal and creative

- Build a personal job-search dashboard
- Curate a Discord channel of weekly design roles
- Run a side-project newsletter for early-career hires
- Compare cities by hiring volume for a relocation decision

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Free job feeds for bootcamp graduates
- Workforce-development programs for under-served regions
- Career fairs powered by live employer rosters
- Investigative reporting on layoff cycles

</td>
<td width="50%">

#### 🧪 Experimentation

- Train classifiers that predict seniority from a description
- Test resume-matching pipelines against fresh listings
- Prototype agents that summarize daily new openings
- Validate product hypotheses with a real jobs feed

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20The%20Muse%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20The%20Muse%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20The%20Muse%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20The%20Muse%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a category, level, location, or company in the input form, click Start, and the Actor applies the filters at the source and emits a clean structured record per job. No browser automation, no captchas, no setup.

#### 📏 How fresh is the data?

Every run pulls the live catalog at request time. Schedule the Actor every few hours to keep a downstream board in near-real time.

#### 🗂️ Which categories are supported?

All 30 verified categories from the source, including Software Engineering, Design and UX, Sales, Healthcare, Education, and 25 more. Pick one from the dropdown or leave it blank for the full catalog.

#### 🌐 Can I filter by remote roles?

Yes. Set the `location` field to `Remote` and the Actor returns jobs flagged as remote-friendly.

#### 📝 Do I get the full description?

Yes. Each record contains both a plain-text `description` and a full `descriptionHtml` field, preserving the source formatting for direct embedding.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync.

#### ⚖️ Is this data legal to use?

The catalog publishes job listings publicly. Review the downstream terms of your specific use case, but publicly listed job postings are generally fair to ingest.

#### 💼 Can I use this data commercially?

Yes. You are responsible for complying with The Muse's terms and with any downstream regulatory requirements in your own product.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

The Muse Jobs Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe job data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh job data into your applicant tracking system, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**💼 Glassdoor Jobs Scraper**](https://apify.com/parseforge/glassdoor-scraper-jobs) - Job listings with company ratings and salary hints
- [**🏢 Greenhouse Jobs Scraper**](https://apify.com/parseforge/greenhouse-jobs-scraper) - Direct-from-employer postings on Greenhouse
- [**🔍 Indeed Scraper**](https://apify.com/parseforge/indeed-scraper) - Aggregated job listings across employers
- [**👔 LinkedIn Jobs Scraper**](https://apify.com/parseforge/linkedin-jobs-scraper) - Professional job postings with company context
- [**🎯 Monster Jobs Scraper**](https://apify.com/parseforge/monster-scraper) - Worldwide job listings with rich detail pages

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more talent and hiring scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by The Muse. All trademarks mentioned are the property of their respective owners. Only publicly available job listings are collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Job function category. Leave blank for all categories.

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

Career level filter.

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

City and state or country, e.g. 'New York, NY', 'San Francisco, CA', 'Remote'. Leave blank for all locations.

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

Optional company name to limit results. Use the company's display name, e.g. 'SpaceX', 'Bank of America', 'Audible, Inc.'.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/themuse-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/themuse-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 '{
  "maxItems": 10
}' |
apify call parseforge/themuse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Muse Jobs Scraper",
        "description": "Export curated jobs and company profiles from The Muse. Search 500k+ openings across tech, marketing, design, sales, and more. Filter by category, location, and experience level. Pull title, company, location, salary hints, description, and apply links.",
        "version": "1.0",
        "x-build-id": "1g9YRRK9mkaTmgLYt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~themuse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-themuse-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/parseforge~themuse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-themuse-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/parseforge~themuse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-themuse-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Account Management",
                            "Accounting and Finance",
                            "Advertising and Marketing",
                            "Business Operations",
                            "Cleaning and Facilities",
                            "Construction",
                            "Customer Service",
                            "Data and Analytics",
                            "Design and UX",
                            "Education",
                            "Energy Generation and Mining",
                            "Farming and Outdoors",
                            "Food and Hospitality Services",
                            "Healthcare",
                            "Human Resources and Recruitment",
                            "Installation, Maintenance, and Repairs",
                            "Legal Services",
                            "Manufacturing and Warehouse",
                            "Media, PR, and Communications",
                            "Personal Care and Services",
                            "Product Management",
                            "Project Management",
                            "Protective Services",
                            "Real Estate",
                            "Retail",
                            "Sales",
                            "Science and Engineering",
                            "Software Engineering",
                            "Transportation and Logistics",
                            "Writing and Editing"
                        ],
                        "type": "string",
                        "description": "Job function category. Leave blank for all categories."
                    },
                    "level": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "Internship",
                            "Entry Level",
                            "Mid Level",
                            "Senior Level"
                        ],
                        "type": "string",
                        "description": "Career level filter."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state or country, e.g. 'New York, NY', 'San Francisco, CA', 'Remote'. Leave blank for all locations."
                    },
                    "company": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Optional company name to limit results. Use the company's display name, e.g. 'SpaceX', 'Bank of America', 'Audible, Inc.'."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
