# SimplyHired Jobs Scraper — Titles, Salary, Company & Skills (`haketa/simplyhired-scraper`) Actor

Scrape jobs from SimplyHired by keyword and location. Get title, company, company rating, salary, job type, skills, benefits, location and full description as clean JSON, CSV or Excel — for recruiting, salary benchmarking and labor-market research.

- **URL**: https://apify.com/haketa/simplyhired-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SimplyHired Jobs Scraper — Titles, Salary, Company, Skills & Full Descriptions

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify)](https://apify.com/haketa/simplyhired-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/simplyhired-scraper)
[![Data Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/simplyhired-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Cursor%20Crawl-success)](https://apify.com/haketa/simplyhired-scraper)
[![Deduplication](https://img.shields.io/badge/Deduplication-JobKey%20Verified-blueviolet)](https://apify.com/haketa/simplyhired-scraper)

Extract comprehensive job postings from [SimplyHired](https://www.simplyhired.com) into clean, structured data without coding or manual browser intervention. This **SimplyHired scraper** crawls jobs by keyword and geographic location, capturing vital employment intelligence: **job title, employer name, employer star rating, published salary ranges, employment classifications, required skills array, benefit packages, application links, geographic coordinates, and full job descriptions**.

Export structured datasets to **JSON, CSV, Excel, or consume records programmatically via the Apify REST API**.

> Built for **recruiters, talent intelligence analysts, HR technology platforms, compensation researchers, job aggregators, and corporate sourcing teams** who require automated, large-scale US job market data extraction.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Platform** | SimplyHired (United States Nationwide Employment Exchange) |
| **Data Types** | Job Postings, Employer Profiles, Salary Disclosures, Skill Arrays |
| **Search Filters** | Multi-keyword list, US city/state/ZIP code, nationwide scope |
| **Pagination Mode** | Continuous cursor-based deep pagination (`maxPagesPerSearch: 0` for auto/unlimited) |
| **Throughput Speed** | Fast listing mode: ~200–500 jobs / min; Detail mode: ~60–120 jobs / min |
| **Data Enrichment** | Structured salary min/max, full sanitized description, skills, company rating |
| **Output Formats** | JSON, CSV, XML, Excel (XLSX), HTML Table |
| **Default Concurrency** | 5 concurrent detail enrichment workers (configurable up to 10) |
| **Proxy Compatibility** | Datacenter first with automatic US Residential fallback |

***

### 🔎 Why scrape SimplyHired?

[SimplyHired](https://www.simplyhired.com) functions as one of North America's premier employment aggregators, consolidating millions of active openings directly from corporate career sites, direct employers, staffing agencies, and partner job boards. Each listing encapsulates valuable market signals: who is actively hiring, published wage distributions, required qualifications, and workplace arrangements (remote, hybrid, or on-site).

Extracting this data manually is hindered by 20-item pagination limits, unformatted compensation strings, and nested descriptions requiring individual page clicks. This **SimplyHired data extractor** automates the end-to-end workflow: sequentially resolving cursor tokens, harvesting multi-page search results, deduplicating records across queries, and returning standardized datasets ready for ATS pipelines and analytics databases.

#### Core enterprise use cases

- **Compensation & Salary Benchmarking**: Aggregate `salaryMin` and `salaryMax` distributions segmented by metropolitan area and job title to establish competitive wage benchmarks.
- **Recruitment & Sourcing Pipelines**: Stream fresh job opportunities and employer expansion signals into applicant tracking systems (ATS) and talent CRM databases.
- **Skill Demand & Tech Trend Analysis**: Track rising technical skills (e.g., Python, Kubernetes, Salesforce) and qualification prerequisites across specific industries.
- **Competitive Hiring Intelligence**: Observe competitor workforce expansion and regional talent acquisition velocity in real time.
- **Aggregated Job Feed Generation**: Seed specialized niche job boards and regional candidate portals with structured, deduplicated vacancy feeds.

***

### ✨ Core capabilities

- ✅ **Multi-Keyword Search Execution**: Crawl multiple job titles or roles simultaneously (`"software engineer"`, `"registered nurse"`, `"accountant"`).
- ✅ **Geographic Precision**: Filter by US metropolitan area, state code, 5-digit ZIP, or leave empty for nationwide aggregation.
- ✅ **Cursor-Based Deep Pagination**: Unlocked pagination engine traverses consecutive pagination tokens without artificial item caps.
- ✅ **Comprehensive Listing Metadata**: Captures job titles, employer names, company ratings, verbatim compensation text, job types, and remote flags directly from search pages.
- ✅ **Full Detail Page Enrichment**: Optionally inspect dedicated job postings to capture full HTML-stripped descriptions, normalized canonical titles, structured salary objects, and application URLs.
- ✅ **Structured Salary Extraction**: Parses compensation ranges into numeric `salaryMin`, `salaryMax`, and `salaryPeriod` properties (`YEAR`, `HOUR`, `MONTH`).
- ✅ **Native Deduplication**: Ensures every vacancy is uniquely validated by SimplyHired `jobKey`, eliminating duplicate entries across overlapping search queries.
- ✅ **Enterprise Export Standards**: Export clean data directly to CSV, JSON, Excel, or consume programmatically via webhooks.

***

### 📥 Input parameters

The scraper accommodates both high-speed search card discovery and deep detail page extraction. All fields are optional; running without input initiates a default software engineering exploration.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | Array of Strings | `["software engineer"]` | Job titles, role keywords, or skill names to search. |
| `location` | String | `"New York, NY"` | Target city, state, or ZIP code (leave blank for nationwide scope). |
| `includeDetails` | Boolean | `false` | When enabled, opens individual job pages to extract full descriptions, coordinates, and apply URLs. |
| `maxPagesPerSearch` | Integer | `0` | Maximum result pages per keyword (20 jobs/page). Set to `0` for unlimited pagination. |
| `maxItems` | Integer | `50` | Maximum total job postings to retain across all keywords. Set to `0` for unlimited. |
| `maxConcurrency` | Integer | `5` | Concurrency for detail page enrichment (1–10). |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Proxy configuration (datacenter with automatic US residential fallback). |

***

### 📋 Ready-to-use input examples

#### Example 1: High-speed listing discovery in Austin

```json
{
  "searchQueries": ["Data Analyst", "Data Engineer"],
  "location": "Austin, TX",
  "includeDetails": false,
  "maxItems": 100,
  "maxPagesPerSearch": 0
}
```

#### Example 2: Full-detail remote healthcare roles

```json
{
  "searchQueries": ["Telehealth Nurse", "Case Manager"],
  "location": "Remote",
  "includeDetails": true,
  "maxItems": 150,
  "maxConcurrency": 5
}
```

#### Example 3: Nationwide engineering sweep

```json
{
  "searchQueries": ["DevOps Engineer"],
  "location": "",
  "includeDetails": false,
  "maxItems": 500,
  "maxPagesPerSearch": 0
}
```

***

### 📤 Output dataset structure

Every vacancy produces a clean JSON record. Below is a representative output record with `includeDetails: true`:

```json
{
  "jobKey": "t4bWK0x5rDdzE6qEiBJ_67Y80jGO0E9j",
  "title": "Senior Backend Software Engineer",
  "normalizedTitle": "senior backend software engineer",
  "company": "Steadily Insurance Agency",
  "companyRating": 4.1,
  "location": "Austin, TX",
  "url": "https://www.simplyhired.com/job/t4bWK0x5rDdzE6qEiBJ_67Y80jGO0E9j",
  "salaryText": "$150,000 - $185,000 a year",
  "salaryMin": 150000,
  "salaryMax": 185000,
  "salaryPeriod": "YEAR",
  "salaryCurrency": "USD",
  "jobTypes": [
    "Full-time"
  ],
  "remoteAttributes": [],
  "workSettings": [
    "Hybrid"
  ],
  "benefits": [
    "Health insurance",
    "401(k) matching",
    "Dental insurance",
    "Paid time off"
  ],
  "requirements": [
    "Mid-level",
    "Python",
    "4 years experience"
  ],
  "skills": [
    "Python",
    "PostgreSQL",
    "Docker",
    "FastAPI",
    "AWS"
  ],
  "qualifications": [
    "Python",
    "Distributed systems",
    "Production APIs"
  ],
  "snippet": "We are seeking a Senior Backend Engineer to architect cloud microservices and scale core insurance platforms...",
  "city": "Austin",
  "state": "TX",
  "latitude": 30.2715,
  "longitude": -97.7419,
  "description": "Full job description text cleanly normalized into readable paragraphs without extraneous HTML tags...",
  "applyUrl": "https://www.simplyhired.com/out?r=...",
  "companyLogo": "https://d3qscgr6xsioh.cloudfront.net/logos/steadily.png",
  "companyPageUrl": "https://www.simplyhired.com/company/steadily-insurance",
  "datePosted": "2026-11-04T08:30:00.000Z",
  "sponsored": false,
  "easyApply": true,
  "expired": false,
  "searchQuery": "backend engineer",
  "searchLocation": "Austin, TX",
  "detailScraped": true,
  "scrapedAt": "2026-11-10T14:45:00.000Z"
}
```

***

### 📊 Field definitions & coverage

#### 💼 Core job metadata

| Field | Type | Description | Coverage |
|---|---|---|---|
| `jobKey` | String | Unique SimplyHired job identifier (deduplication key) | 🟢 High (100%) |
| `title` | String | Original job title as published | 🟢 High (100%) |
| `normalizedTitle` | String | Standardized job taxonomy title *(details on)* | 🟢 High (98%) |
| `url` | String | Canonical URL to the SimplyHired job posting | 🟢 High (100%) |
| `snippet` | String | Short excerpt displayed on search cards | 🟢 High (100%) |
| `description` | String | Complete plain text sanitized job specification *(details on)* | 🟢 High (99%) |
| `datePosted` | String | ISO 8601 publication timestamp | 🟢 High (100%) |
| `easyApply` | Boolean | True if SimplyHired one-click application is supported | 🟢 High (100%) |
| `sponsored` | Boolean | Flag indicating sponsored employer placement | 🟢 High (100%) |
| `applyUrl` | String | Direct external application URL *(details on)* | 🟢 High (92%) |

#### 🏢 Employer details

| Field | Type | Description | Coverage |
|---|---|---|---|
| `company` | String | Legal or operating employer name | 🟢 High (100%) |
| `companyRating` | Number | Employer review star rating (1.0–5.0 scale) | 🟡 Conditional (70%) |
| `companyLogo` | String | CDN URL to the corporate logo image *(details on)* | 🟡 Conditional (75%) |
| `companyPageUrl` | String | SimplyHired corporate overview profile link *(details on)* | 🟡 Conditional (80%) |

#### 📍 Location & workplace arrangement

| Field | Type | Description | Coverage |
|---|---|---|---|
| `location` | String | Formatted display location string | 🟢 High (100%) |
| `city` | String | Municipality jurisdiction *(details on)* | 🟢 High (94%) |
| `state` | String | Two-letter state postal abbreviation *(details on)* | 🟢 High (94%) |
| `latitude` / `longitude` | Number | Geocoded geographic coordinates *(details on)* | 🟢 High (90%) |
| `workSettings` | Array | Workplace tags (`Remote`, `Hybrid`, `In-Office`) | 🟢 High (90%) |

#### 💰 Compensation & qualifications

| Field | Type | Description | Coverage |
|---|---|---|---|
| `salaryText` | String | Verbatim compensation string as published | 🟡 Conditional (75%) |
| `salaryMin` | Number | Parsed minimum compensation numeric value *(details on)* | 🟡 Conditional (55%) |
| `salaryMax` | Number | Parsed maximum compensation numeric value *(details on)* | 🟡 Conditional (55%) |
| `salaryPeriod` | String | Pay period frequency (`YEAR`, `HOUR`, `MONTH`) *(details on)* | 🟡 Conditional (55%) |
| `salaryCurrency` | String | Currency standard (`USD`, `CAD`) *(details on)* | 🟡 Conditional (55%) |
| `skills` | Array | Required or preferred technology and professional skills | 🟢 High (95%) |
| `benefits` | Array | Disclosed employee benefits (healthcare, 401k, PTO) | 🟢 High (85%) |
| `qualifications` | Array | Explicit prerequisites and experience thresholds | 🟢 High (80%) |

***

### 💡 Search strategies & best practices

1. **High-Speed Aggregation First**: When collecting broad talent market data, run with `includeDetails: false`. The listing view provides salary text, company ratings, and skill tags at high throughput (~500 records/minute).
2. **Selective Detail Enrichment**: Identify high-priority job openings from the listing run, then re-execute specifically for those `jobKey` values with `includeDetails: true` to capture full descriptions and apply URLs.
3. **Multi-Query Keyword Sweeps**: Group related titles together (e.g. `["Nurse Practitioner", "Family Nurse Practitioner", "ARNP"]`) to capture total market inventory. The actor automatically discards duplicate postings.
4. **Scheduled Automated Ingestion**: Set up an Apify Schedule (e.g. daily at 07:00 AM) to capture fresh vacancies published over the last 24 hours, feeding new records directly into your sourcing CRM.

***

### ⚙️ How to use

1. Enter target job keywords in `searchQueries` (e.g. `["Product Manager"]`) and define a `location`.
2. Choose whether to enable `includeDetails` based on your project requirements.
3. Set `maxItems` and keep `maxPagesPerSearch: 0` for complete cursor-based pagination.
4. Click **Start** in the Apify Console and monitor live event logs.
5. Export your structured job dataset in JSON, CSV, or Excel formats.

***

### 💻 API & Integration examples

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~simplyhired-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["Data Scientist"],
    "location": "Boston, MA",
    "includeDetails": false,
    "maxItems": 100,
    "maxPagesPerSearch": 0
  }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQueries": ["DevOps Engineer"],
    "location": "Seattle, WA",
    "includeDetails": True,
    "maxItems": 150
}

run = client.actor("haketa/simplyhired-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item.get('title')} at {item.get('company')} — Salary: {item.get('salaryText', 'Not Listed')}")
```

#### Node.js / JavaScript

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const runInput = {
    searchQueries: ['Software Engineer'],
    location: 'New York, NY',
    maxItems: 50,
    includeDetails: false,
};

const run = await client.actor('haketa/simplyhired-scraper').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Extracted ${items.length} SimplyHired job records.`);
```

#### Webhook & Workflow Automation

Connect this scraper directly to your workflow tools:

- **Make (Integromat)**: Create a scenario triggered by an Apify "Run Succeeded" webhook. Parse the resulting dataset and automatically append records to Google Sheets, Notion, or Airtable.
- **Zapier**: Connect the Apify app, listen for dataset item creation, and send Slack notifications whenever a target company posts a new executive technology role.
- **AWS S3 / Google Cloud Storage**: Use Apify Integrations to automatically sync every completed dataset to cloud storage buckets for enterprise data lakes.

***

### ❓ Frequently Asked Questions

**How does deep pagination function on SimplyHired?**
SimplyHired delivers listings in ~20-job pages navigated via sequential cursor tokens. When `maxPagesPerSearch` is set to `0`, the scraper automatically traverses every available cursor until `maxItems` is satisfied or all matching positions are retrieved.

**Why are structured salary fields null on some records?**
Compensation disclosures on SimplyHired depend on employer transparency. When an employer publishes an explicit salary or hourly wage, the scraper captures the text and parses it into `salaryMin` and `salaryMax`. Postings without salary remain null for structured fields.

**What proxy settings are recommended?**
The scraper features automated proxy routing that utilizes datacenter IPs first, automatically rotating to US residential proxies when necessary. Retaining the default `{ "useApifyProxy": true }` is strongly recommended.

**Can I run scheduled sweeps for fresh postings?**
Yes. You can configure an Apify Schedule (e.g., daily at 08:00 UTC) to build an automated pipeline capturing new vacancies every morning without duplicates.

**What is the difference between listing summary and full detail mode?**
In listing summary mode (`includeDetails: false`), the scraper extracts metadata visible on search result cards (title, company, display location, salary text, skills snippet, posted date) at very high speeds (~500 items/minute). In full detail mode (`includeDetails: true`), the actor concurrently visits each posting's dedicated view to extract full HTML-stripped descriptions, normalized job titles, company profile links, and direct application URLs.

**Can I export data directly to Excel or CSV?**
Yes. From the Apify Dataset tab, you can download all extracted fields in CSV, Excel (XLSX), JSON, XML, or HTML table formats with a single click.

***

### 🔗 Related employment scrapers

- [Dice Job Scraper](https://apify.com/haketa/dice-scraper) — Deep technology recruitment intelligence and developer skill tags.
- [ZipRecruiter Jobs Scraper](https://apify.com/haketa/ziprecruiter-scraper) — Multi-country job board data with parsed compensation.
- [CutShort Jobs Scraper](https://apify.com/haketa/cutshort-scraper) — India tech job listings and developer salary data.
- [Glassdoor Jobs Scraper](https://apify.com/haketa/glassdoor-jobs-scraper) — Company reviews, salaries, and open positions.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Deep Cursor Pagination Unlock**: Unlocked 1,000+ continuous result pagination with configurable `maxPagesPerSearch` (0 = auto/unlimited) and removal of legacy page bounds.
- **Fast Prefill Optimization**: Streamlined default execution parameters ensuring sample test runs complete in under 30 seconds.
- **Schema Hardening**: Standardized integer limits to minimum 0 and cleansed dataset schemas for strict specification compliance.
- **Deduplication Safeguards**: Hardened `jobKey` verification preventing duplicate records across overlapping multi-keyword search queries.

#### v1.1 (2026-10)

- Enhanced structured salary parser extracting annual and hourly compensation objects.
- Added support for normalized canonical job titles in detail enrichment mode.

#### v1.0 (2026-09)

- Initial production release supporting multi-keyword discovery, location filtering, and structured JSON/CSV exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/simplyhired-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Job keywords or titles to search (e.g. software engineer, registered nurse, warehouse). Leave empty to get the most recent jobs for the location.

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

City, state or ZIP to search in (e.g. New York, NY). Leave empty for nationwide.

## `includeDetails` (type: `boolean`):

Fetch each job's page to add the full description, structured salary (min/max/period), qualifications, coordinates, company rating and apply link. Slower and costs more.

## `maxPagesPerSearch` (type: `integer`):

Maximum result pages per keyword (each page has ~20 jobs). Set to 0 for unlimited / automatic pagination governed by Maximum jobs.

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

Stop after collecting this many jobs across all keywords. Set to 0 for unlimited.

## `maxConcurrency` (type: `integer`):

How many job pages to fetch in parallel when full details are on.

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

Residential US proxy is recommended. The actor uses datacenter first and falls back to US residential automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "registered nurse",
    "data analyst",
    "sales"
  ],
  "location": "New York, NY",
  "includeDetails": false,
  "maxPagesPerSearch": 0,
  "maxItems": 50,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchQueries": [
        "software engineer"
    ],
    "location": "New York, NY",
    "maxPagesPerSearch": 0,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/simplyhired-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 = {
    "searchQueries": ["software engineer"],
    "location": "New York, NY",
    "maxPagesPerSearch": 0,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/simplyhired-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 '{
  "searchQueries": [
    "software engineer"
  ],
  "location": "New York, NY",
  "maxPagesPerSearch": 0,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/simplyhired-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/simplyhired-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/6H7td9cce9bx30iyj/builds/wLpW7S0p89pIriTXK/openapi.json