# Hiring Leads Scraper: Companies Hiring Now & Decision Makers (`moggedhq/hiring-leads`) Actor

Find companies hiring right now for any role, with job postings, hiring contacts and emails, e.g. software engineers in Texas, nurses in Florida or remote sales reps. $0.015 per company lead, $0.02 per decision-maker email. Company, website, open roles from Greenhouse, Lever, Ashby and more.

- **URL**: https://apify.com/moggedhq/hiring-leads.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 hiring companies

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

## Hiring Leads Scraper: Companies Hiring Now & Decision Makers

**Find companies hiring for a role right now, with the job postings, the hiring contacts and their emails: for example software engineers in Texas, nurses in Florida or remote sales reps.**

**For recruiters, staffing and recruitment agencies, and B2B sales teams.** Tell it the roles and the place ("software engineer" in "Texas", "registered nurse" in "Florida", "account executive", "Remote"). You get **one sales-ready lead per company that is hiring for those roles right now**: the company, its website, the matching open roles with links to the postings on its own careers page, how many matching roles are open (hiring intensity), and, where the company publishes them, **the decision makers to contact, with any email labelled by how it was found and a confidence level**.

**Price: $0.015 per company lead and $0.02 per decision-maker email** (high or medium confidence only). Most leads cost $0.015; a lead with one confirmed email costs about $0.035. Platform usage is included. Companies with no matching roles, roles that have closed, names and titles, and low-confidence email guesses are free.

No LinkedIn, Indeed or Glassdoor scraping and no account or cookies needed: the roles come straight from the employers' own job boards.

#### What to expect

Measured on 215 leads from 12 test searches on 12 October 2026:

| What you get | How often |
|---|---|
| Matching open roles, checked again on the employer's live careers page during your run | every lead (14 of 14 also checked by hand) |
| At least one named decision maker (name, title, source page) | about half of companies (53%): 65% to 75% in UK, European and remote-sales searches, about 40% for US engineering roles, about 30% for healthcare employers |
| A charged email with high or medium confidence (published, or built from the company's confirmed email format) | about 2 in 100 companies |
| A free low-confidence email guess, to check with a verifier before use | about half of companies |
| Run time | 10 to 100 seconds for 5 to 50 companies |

So think of this as a list of companies hiring now with the right people named, not as a bulk email finder. Confirmed emails are a bonus where companies publish their staff addresses.

#### What one lead looks like

Real output from a test search on 12 October 2026 ("software engineer" in Texas, posted within 7 days). Contact names are in your results and left out of these pictures.

![Hiring Leads table: company, newest matching role, matching and open roles, hiring intensity, posting date, job board, best contact and email confidence, from a real Texas search](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/hiring-leads-table-v2.png)

![One hiring lead in full: company details, the matching role with a link to the posting, three decision makers with titles and where they were found, and the lead summary](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/hiring-leads-lead-detail-v2.png)

More rows from other test searches on the same day (people's names left out here; your results include them):

| Company | Hiring for | Location | Matching roles / all open | Posted | Best contact found | Email confidence |
|---|---|---|---|---|---|---|
| Pariveda | Software Engineer II | Dallas | 1 / 27 | 9 Oct | Managing Vice President, Central Region (team page) | low (free) |
| DomainTools | Principal Software Engineer | Austin, Texas | 1 / 11 | 9 Oct | Chief Executive Officer (about page) | low (free) |
| Saronic Technologies | Software Engineer, Forward Deployed | Austin, TX | 2 / 210 | 5 Oct | Chief People Officer (team page) | low (free) |
| VitalCaring Group | Home Health LVN | San Antonio, Texas | 54 / 427 | 11 Oct | Senior Vice President, Human Resources (about page) | low (free) |
| IVX Health | Infusion Registered Nurse | Brooklyn, New York | 10 / 73 | 8 Oct | Director of Nursing (team page) | low (free) |
| Wayve | Senior Software Engineer, Data | London | 4 / 157 | 6 Oct | Engineering Manager (team page) | low (free) |

Every row also includes the company website and description, a link to each posting on the employer's own careers page, the careers page itself, the total number of open roles, other published company addresses (careers@, hr@), the company's email format when we can confirm it, and a one-line `leadSummary` ready for your CRM or an AI agent.

#### How to use it

1. **Open the Actor and fill in the form.** Click **Try for free** on this page (or open the Actor in Apify Console). Type the **job titles** you recruit or sell for, one per line ("software engineer", "data engineer"), and the **location**: a US state, city, country, region ("Europe", "DACH") or "Remote". Choose **posted within** (default 7 days) and **how many companies** you want.
2. **Press Start.** 5 to 50 companies take 10 to 100 seconds.
3. **Download the results.** When the run finishes, open the **Output** tab and click **Export** to download **Excel** or **CSV** (JSON, XML and Google Sheets work too). Use the **Leads** view for one company per row, **Contacts** for one row per person (ready for an outreach tool) or **Open roles** for one row per job posting.

#### Schedule it: a daily feed of companies newly hiring

Save your search as a task, set **Posted within** to 1 day and turn on **Only companies not delivered before**, then add a daily **Schedule**. Each morning you get only the companies that started hiring for your roles since yesterday. Connect the run to Google Sheets, Slack, HubSpot, Clay, Make, n8n or Zapier with Apify's integrations.

#### Where the data comes from

![How Hiring Leads works: you choose roles and location, it searches a daily index of about 16,000 company careers pages, re-checks each role live, finds decision makers and returns one lead per company](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/hiring-leads-how-it-works-v2.png)

- **Open roles:** the public job boards companies run on **Greenhouse, Lever, Ashby, Workable, Personio and Recruitee**, through the public job-posting endpoints these platforms provide for careers pages. About 16,000 live company job boards are read into a daily index of roles posted in the last 31 days (around 10,000 companies with recent roles at any time); platforms that limit request rates are read in turns over two or three days. When you run a search, each company's roles are checked again on its live careers page, so closed roles are dropped before you pay.
- **Contacts:** the company's own website (team, about, leadership, contact and legal-notice pages, and schema.org data) and the job postings themselves (named hiring managers, recruiters and "you will report to" lines). LinkedIn is never visited; a LinkedIn profile link appears only when the company's own website links to it.

#### How emails are found, and what the confidence means

| Confidence | What it means | Charged |
|---|---|---|
| **high** | The address itself is published on the company's website or in its job posting, next to that person or spelt from their name. | yes, $0.02 |
| **medium** | Built from the company's own email format (for example first.last@), learnt from at least one published address on the same domain that spells the name of a person on the company's pages. City, office and team inboxes (dallas@, sales@) never count. The domain has mail servers. | yes, $0.02 |
| **low** | Built from the most common format for a company of that size. The domain has mail servers, but nothing published confirms the format. Check it with an email verifier before sending. | no, free |

Every email comes with `emailSource`, a sentence saying exactly where it came from. A guess is never presented as verified. Addresses are not tested by sending mail.

#### Who is chosen as the contact

Up to 3 people per company (change it with **Maximum contacts per company**), best first:

1. the leader of the team that is hiring (CTO or VP Engineering for engineering roles, VP Sales for sales roles, Director of Nursing for nursing roles, and so on), and anyone named in the posting itself;
2. HR, talent acquisition and recruiting leaders;
3. founders, the CEO, owners and managing directors (first choice at small companies).

#### Input fields

| Field | What it does |
|---|---|
| `jobTitles` | Roles to find, in plain words. Common variants are included ("nurse" also finds RN and LPN roles). Empty means every role. |
| `location` | US state, city, country, region or "Remote". Separate several with a semicolon. |
| `postedWithinDays` | Only roles posted in the last 1 to 30 days. |
| `maxCompanies` | How many company leads to deliver. |
| `includeContacts` | Find decision makers and emails (on by default). |
| `remote` | Any, remote only, or on-site and hybrid only. |
| `companySize` | Small, mid-size or large, estimated from how many roles the company has open in total (job boards do not publish headcount). |
| `industry` | Only companies whose own description mentions these words ("healthcare", "fintech", "SaaS"). |
| `excludeTitles`, `excludeCompanies` | Leave out roles or companies (for example "intern", or your existing clients). |
| `minMatchingRoles` | Only companies with at least this many matching roles. |
| `excludeStaffingAgencies` | Skip agencies that post jobs for their clients (on by default). |
| `skipCompaniesFromPreviousRuns` | For scheduled feeds: only companies not delivered before. |

Example input:

```json
{
  "jobTitles": ["software engineer", "data engineer"],
  "location": "Texas",
  "postedWithinDays": 7,
  "maxCompanies": 100,
  "includeContacts": true
}
```

#### Output fields

| Field | What it is |
|---|---|
| `company`, `website`, `domain`, `companyDescription`, `industry` | The company that is hiring |
| `atsPlatform`, `careersPageUrl` | The job board the roles come from and the company's careers page |
| `matchingRolesCount`, `openRolesTotal`, `hiringIntensity` | How many roles match your search, how many are open in total, and high, medium or low intensity |
| `topRoleTitle`, `topRoleUrl`, `topRoleLocation`, `newestRolePostedAt` | The newest matching role, its link, location and posting date |
| `roleTitles`, `matchingRoles` | Every matching role with title, location, remote or on-site, department, posting date and link (up to 25) |
| `rolesVerifiedOpen` | True when the roles were checked as still open on the live careers page during your run |
| `contacts` | Up to 3 decision makers: name, title, the page they were found on, email, `emailConfidence`, `emailSource` and LinkedIn when the company site links it |
| `bestContactName`, `bestContactTitle`, `bestContactEmail`, `bestContactEmailConfidence` | The best person to contact first |
| `companyEmails`, `emailFormat`, `emailDomainAcceptsMail` | Published company addresses (careers@, hr@), the confirmed email format and whether the domain accepts mail |
| `leadSummary` | One sentence about the lead, ready for a CRM note or an AI agent |
| `matchedKeywords`, `searchQuery`, `notes`, `chargedEmails`, `scrapedAt` | Which titles matched, the search used, notes, emails charged and when the lead was built |

#### How much does it cost?

You pay per result, nothing for platform usage:

- **$0.015 per company lead** (a company with at least one matching open role, checked live).
- **$0.02 per decision-maker email** with high or medium confidence.

| You get | You pay |
|---|---|
| 100 companies, contacts off | $1.50 |
| 100 companies with contacts | $1.50 plus $0.02 per confirmed email: about $1.60 in our tests |
| 1,000 companies with contacts | about $16 |

Names and titles of decision makers come free with each lead. Emails are charged only at high or medium confidence, which we reach for the few companies that publish staff addresses; for the rest you get a free low-confidence guess to verify yourself.

Set **Maximum cost per run** in the run options and the Actor stops there. Higher Apify plans get a discount.

#### Hiring Leads compared with the alternatives

| | Hiring Leads | LinkedIn Jobs scraper plus an email finder | Apollo, ZoomInfo |
|---|---|---|---|
| Who is hiring, by role and place | yes | yes | partly |
| Decision makers | names and titles for about half of companies, in the same row; confirmed emails for a few | a second tool, matched by hand | yes, with emails |
| Job source | the employer's own careers page | LinkedIn listings (often reposts) | mixed |
| Confidence and source for every email | yes | varies | no |
| Price | $0.015 per company, $0.02 per confirmed email | two tools, two bills | seat licences, often thousands a year |
| Account or cookies needed | no | often | yes |

#### Use it from code (API)

Every example below starts a run, waits for it to finish and reads the results. Replace `YOUR_APIFY_TOKEN` with your token from Apify Console (**Settings**, **API & Integrations**). Each item is one company lead; the fields are listed under **Output fields** above.

**Python** (`pip install apify-client`, version 3 or later)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("moggedhq/hiring-leads").call(run_input={
    "jobTitles": ["software engineer"],
    "location": "Texas",
    "postedWithinDays": 7,
    "maxCompanies": 5,
})

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["company"], item["topRoleTitle"], item["bestContactTitle"])
```

**JavaScript / Node.js** (`npm install apify-client`, save as `main.mjs`)

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

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

const run = await client.actor('moggedhq/hiring-leads').call({
    jobTitles: ['software engineer'],
    location: 'Texas',
    postedWithinDays: 7,
    maxCompanies: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((lead) => console.log(lead.company, lead.topRoleTitle, lead.bestContactTitle));
```

**cURL** (waits for the run and saves the results as a CSV file; use `format=json` or `format=xlsx` for other formats)

```bash
curl -X POST "https://api.apify.com/v2/acts/moggedhq~hiring-leads/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jobTitles": ["software engineer"], "location": "Texas", "postedWithinDays": 7, "maxCompanies": 5}' \
  -o results.csv
```

##### No-code: n8n, Make and Zapier

- **n8n:** add the Apify node, choose the **Run Actor** operation and pick `moggedhq/hiring-leads`, or call the cURL address above from an **HTTP Request** node.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to pass each row to Google Sheets, a CRM or email.
- **Zapier:** use the Apify app's **Run Actor** action, or the **Finished Actor Run** trigger to send every new result set to Sheets, Slack or your CRM.

#### Use with AI agents (MCP)

The Apify MCP server (`https://mcp.apify.com`) lets Claude, ChatGPT, Cursor, VS Code and other MCP clients call this Actor as a tool, fill in the input from a plain request, and read the rows back. Each row has a `leadSummary` sentence written for agents and CRM notes, and the inputs use plain words (`jobTitles`, `location`, `postedWithinDays`, `maxCompanies`).

**Claude Code:**

```bash
claude mcp add apify "https://mcp.apify.com/?tools=moggedhq/hiring-leads" -t http
```

**Cursor, VS Code and other clients that take a server URL** (`mcp.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=moggedhq/hiring-leads"
    }
  }
}
```

**Clients that only run local servers:**

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "moggedhq/hiring-leads"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Example prompt:

> Find 20 companies in Texas hiring software engineers this week, with the best person to contact at each and a link to the job posting.

The agent reads `company`, `topRoleTitle`, `topRoleUrl`, `matchingRolesCount`, `bestContactName`, `bestContactTitle` and `leadSummary`, and only treats emails with `bestContactEmailConfidence` high or medium as confirmed.

#### Use cases

- **Staffing and recruitment agencies:** find companies with open roles you can fill, and the hiring manager or head of talent to pitch.
- **Recruiters:** build a business-development list for your niche every morning.
- **B2B sales:** companies hiring sales reps need sales tools; companies hiring engineers need dev tools; companies hiring nurses need healthcare staffing and scheduling. Hiring is a buying signal.
- **AI agents and automations:** one call returns ready leads with a summary sentence per company.

#### FAQ

**Is this legal?** It reads public job postings that employers publish to attract applicants, and business contact details companies publish about their own staff. It does not log in or read LinkedIn, Indeed or Glassdoor. The results contain personal data (names, job titles, work emails), so you are responsible for having a lawful basis to use them (for example legitimate interest under GDPR) and for following anti-spam rules such as CAN-SPAM, CASL and the GDPR when you contact people. If in doubt, ask a lawyer.

**Is this affiliated with LinkedIn, Greenhouse, Lever, Workday or any job board platform?** No. Hiring Leads is an independent tool. It is not affiliated with, endorsed or sponsored by LinkedIn, Greenhouse, Lever, Ashby, Workable, Personio, Recruitee, Workday, Apollo, ZoomInfo or any other company named on this page. Their names are used only to describe where public job postings come from and how the tool compares.

**Do I need an account anywhere?** Only your Apify account. No LinkedIn or other logins, no cookies.

**Why do some companies have no contacts?** Large companies rarely publish their team on their website, and contacts are only taken from public pages. Small and mid-size companies, startups and European companies (which publish a legal notice naming their managing directors) give the best results. You only pay for emails that are high or medium confidence.

**How fresh is it?** The index of roles is rebuilt every day from about 16,000 company job boards (Workable and Lever boards are read in turns over two or three days because those platforms limit request rates), and the roles of every company you receive are checked again on its live careers page during your run, so closed roles are dropped.

**Which countries?** Any. Coverage is strongest in the United States, the United Kingdom and Europe, where these job boards are most used.

**Why not Workday, BambooHR, Breezy HR or SmartRecruiters?** The website terms of Workday, BambooHR and Breezy HR forbid automated access, and SmartRecruiters' robots.txt blocks its job API, so this Actor does not read them. Employers that only use those systems (or iCIMS, Taleo and similar) are not covered yet.

**Can I use it from my code or an AI agent?** Yes: through the Apify API, the Apify MCP server, or integrations such as Make, n8n, Zapier and Clay (see **Use it from code** and **Use with AI agents** above). Each row has a `leadSummary` sentence for agents and CRM notes.

#### More tools from mogged

- [Recently Funded Startups](https://apify.com/moggedhq/recently-funded-startups): startups that just raised a round, with founders and contacts
- [Google Ads Keyword Planner Scraper](https://apify.com/moggedhq/keyword-search-volume): Google search volume, CPC and keyword difficulty for any keyword list
- [Google Maps Rank Tracker](https://apify.com/moggedhq/google-maps-rank-tracker): geo grid rank checks and heatmaps for local SEO
- [Technical SEO Audit Tool](https://apify.com/moggedhq/seo-audit-tool): a full website SEO audit with a score and a fix list

# Actor input Schema

## `jobTitles` (type: `array`):

The roles companies are hiring for, in plain words, for example "software engineer", "registered nurse", "account executive" or "warehouse". A job matches when its title contains all the words of any entry (common variants are included: "nurse" also finds RN and LPN roles). Leave empty to get every role in the location.

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

Where the jobs are: a US state ("Texas" or "TX"), a city ("Austin, TX", "London"), a country ("United States", "Germany"), a region ("Europe", "DACH", "APAC") or "Remote". Separate several places with a semicolon: "Texas; Florida". Leave empty for anywhere.

## `postedWithinDays` (type: `integer`):

Only roles first posted in this many days (1 to 30). Use 1 with a daily schedule to get a feed of companies that are newly hiring.

## `maxCompanies` (type: `integer`):

How many companies to deliver. Each company row is one lead. The run also stops at your maximum charge per run.

## `includeContacts` (type: `boolean`):

Find people to contact at each company (founders, executives, hiring managers, HR and talent leaders) on the company's own website and in its job postings, with emails labelled by confidence. Turn off for a faster list of companies and roles only.

## `maxContactsPerCompany` (type: `integer`):

Up to this many people per company, best match first (the leader of the team that is hiring, then HR and talent, then founders and executives).

## `remote` (type: `string`):

Any: all roles. Remote only: roles marked remote. On-site or hybrid only: leave remote roles out.

## `companySize` (type: `string`):

Job boards do not publish headcount, so size is estimated from how many roles the company has open in total. Small: fewer than 20 open roles. Mid-size: 20 to 199. Large: 200 or more.

## `industry` (type: `array`):

Only companies whose own description mentions one of these words, for example "healthcare", "fintech", "SaaS", "manufacturing" or "logistics". Companies that do not match are skipped and not charged.

## `excludeTitles` (type: `array`):

Leave out roles whose title contains any of these words, for example "intern", "senior" or "manager".

## `minMatchingRoles` (type: `integer`):

Only companies with at least this many matching open roles (a hiring-intensity filter). 1 keeps every hiring company.

## `excludeStaffingAgencies` (type: `boolean`):

Skip agencies that post jobs for their clients, so you only get the employers themselves.

## `excludeCompanies` (type: `array`):

Company names or website domains to leave out, for example your existing clients.

## `skipCompaniesFromPreviousRuns` (type: `boolean`):

For scheduled runs: leave out companies this search already delivered in earlier runs, so each run brings only new leads. Uses a small storage in your account named after the search.

## `atsPlatforms` (type: `array`):

Which company career-site platforms to search. All are searched by default.

## Actor input object example

```json
{
  "jobTitles": [
    "software engineer"
  ],
  "location": "United States",
  "postedWithinDays": 7,
  "maxCompanies": 5,
  "includeContacts": true,
  "maxContactsPerCompany": 3,
  "remote": "any",
  "companySize": "any",
  "industry": [],
  "excludeTitles": [],
  "minMatchingRoles": 1,
  "excludeStaffingAgencies": true,
  "excludeCompanies": [],
  "skipCompaniesFromPreviousRuns": false,
  "atsPlatforms": [
    "greenhouse",
    "lever",
    "ashby",
    "workable",
    "personio",
    "recruitee"
  ]
}
```

# Actor output Schema

## `leads` (type: `string`):

One row per hiring company: roles, hiring intensity and the best contact.

## `contacts` (type: `string`):

The same leads with one row per decision maker, for outreach lists.

## `roles` (type: `string`):

The same leads with one row per matching job posting.

## `all` (type: `string`):

Full rows with every field, as JSON.

# 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 = {
    "jobTitles": [
        "software engineer"
    ],
    "location": "United States",
    "postedWithinDays": 7,
    "maxCompanies": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/hiring-leads").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 = {
    "jobTitles": ["software engineer"],
    "location": "United States",
    "postedWithinDays": 7,
    "maxCompanies": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/hiring-leads").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 '{
  "jobTitles": [
    "software engineer"
  ],
  "location": "United States",
  "postedWithinDays": 7,
  "maxCompanies": 5
}' |
apify call moggedhq/hiring-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/hiring-leads"
        }
    }
}
```

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/tAgjiaLqEGkM5r2YH/builds/bkfxY56o6w92ca1yG/openapi.json