# Torre Jobs & Recruiters Scraper: Tech Jobs + Hiring Contacts (`oswaldocarabano/torre-jobs-recruiters-scraper`) Actor

Scrape open remote tech jobs from Torre (torre.ai) with the recruiter who posted them, the company website and domain, salary, skills and team. Optional recruiter profile (LinkedIn, location) and company email pattern from DNS. Open jobs only by default.

- **URL**: https://apify.com/oswaldocarabano/torre-jobs-recruiters-scraper.md
- **Developed by:** [Oswaldo Carabano](https://apify.com/oswaldocarabano) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Torre Jobs & Recruiters Scraper: Remote Tech Jobs and Hiring Contacts

**Export open job posts from [Torre](https://torre.ai) with the person who posted
them, the hiring team, the company website and email domain, salary, skills and
remote policy.** Or export the **recruiters themselves**: one row per company
person who publishes jobs, with their public Torre profile, LinkedIn, location and
the jobs they posted. Optional **company email pattern** from DNS (MX records only).

- **Open jobs only by default.** Torre keeps closed posts in its search: of 2,813
  remote "software engineer" posts on 1 Oct 2026, only 65 were open. This actor
  filters them for you (or returns closed ones on request).
- **Who to contact:** the company person who posted the job in 97.1% of posts
  published by companies, plus the visible hiring team (often founders and CEOs).
- **Company domain** in 79.1% of job posts (87.7% of posts published by companies),
  cleaned from job-board and social links.
- **Or bring your own job links** (`jobUrls`): paste Torre job URLs and get each one
  enriched with the team, company domain, recruiter profile and email pattern.
- **No login, no cookies, no browser, no proxy needed.** On Apify (2 Oct 2026, 512 MB):
  50 job posts with full pages in 9 s, 400 with recruiter profiles in 80 s.
- **$3 per 1,000 job posts**, $8 per 1,000 full job pages. You never pay for an
  error, a duplicate or a failed page.

***

### What people use it for

| If you are… | You get |
|---|---|
| A **developer in Latin America** looking for remote work | open remote tech jobs, salary range in USD, time zones, and the person who posted each one |
| A **recruiter or staffing agency** | companies hiring right now, their website, domain, team size and hiring contacts |
| Doing **B2B lead generation** for HR tech | companies with open roles, decision-makers on the hiring team, LinkedIn profiles, email provider |
| Building a **job board or salary dataset** | full descriptions, compensation (min, max, currency, hourly USD), skills, languages, contract type |

***

### Two row types (one per run)

| `outputType` | One row per | Main content |
|---|---|---|
| `jobs` *(default)* | job post | title, company, domain, salary, skills, remote policy, countries, posted by, hiring team, full description |
| `recruiters` | company person who publishes jobs (deduplicated) | name, headline, Torre profile, LinkedIn and other links, location, current position, jobs posted, guessed email |

Torre had **16,699 open job posts** on 1 Oct 2026 (363,939 including closed ones);
**2,718 open posts were remote.** Open + remote, by role: QA engineer 311, data
engineer 178, software engineer 66, product manager 64, designer 38, mobile 23,
backend 23, full stack 22.

#### How the search works (and what it does not promise)

Since 2 Oct 2026 Torre only answers job searches made *for a person* (its "best for
you" ranking). The actor runs every search with the public Torre account of Torre's
founder as that context, with all of that person's skills, experience and job
preferences removed from the query, so the results depend on your filters and not
on someone's profile. No login, no account.

- **Remote jobs:** one search, close to everything Torre has. Measured on 2 Oct 2026:
  2,617 open remote posts (2,718 on 1 Oct with the old search) and remote "software
  engineer" **65 of 65**.
- **On-site and hybrid jobs** (`remoteOnly: false`): Torre only returns those near a
  location, so the actor searches around the main cities of each country you pick
  (about 30-50 km each; 81 cities in 60 countries without a country filter) and
  removes duplicates. Coverage is by city, **not exhaustive**: an on-site job in a
  small town far from those cities will not show up. Measured on 2 Oct 2026 with no filters at all
  (remote + on-site, all countries): **14,684 unique open posts in 9 minutes, 88% of the
  16,699** Torre listed on 1 Oct with its old search; 91% of the job posts in Torre's own
  sitemaps were found.
- Results come in Torre's **relevance order**, not by date.

#### Job posts published by companies vs aggregated by Torre

On 1 Oct 2026, **58.2% of open posts were aggregated by Torre** from other job sites
(`postedByTorre: true`, `crawled: true`). They come with the original application
link (`externalApplicationUrl`, 100%) but **no company recruiter**: they are posted
by Torre's own account. They often list the company's founders as the hiring team
(48.4% have at least one company person). The other 41.8% are published by the
company on Torre and carry a real recruiter in 97.1% of cases.

***

### What actually arrives in a row

Measured on 1 Oct 2026 on 330 open job posts with the full job page (138 published
by companies, 192 aggregated by Torre) and 90 recruiter profiles.

| Field | All | By companies | Aggregated |
|---|---|---|---|
| title, tagline, status, remote, created | 100% | 100% | 100% |
| organization name | 98.2% | 95.7% | 100% |
| skills | 96.7% | 100% | 94.3% |
| website | 95.8% | 89.9% | 100% |
| domain | 79.1% | 87.7% | 72.9% |
| full description, languages | 100% | 100% | 100% |
| countries / locations | 76.4% | 64.5% | 84.9% |
| deadline | 70.9% | 31.2% | 99.5% |
| salary minimum | 40.9% | 63.8% | 24.5% |
| salary maximum | 35.5% | 53.6% | 22.4% |
| company person who posted it | 40.6% | 97.1% | 0% |
| their headline | 30.3% | 72.5% | 0% |
| visible hiring team (≥ 1 company person) | 69.7% | 99.3% | 48.4% |
| company rating on Torre (1–5) | 56.4% | 79.7% | 39.6% |
| applicant feedback summaries | 22.4% | 53.6% | 0% |
| contract type | 83.0% | 82.6% | 83.3% |
| email address in the description | 2.1% | 0% | 3.6% |
| countries applicants may live in | 67.9% | 84.1% | 56.3% |
| job address (country, region, street) | 56.7% | 65.2% | 50.5% |
| job location coordinates | 76.4% | 64.5% | 84.9% |
| education requirement | 56.4% | 62.3% | 52.1% |
| months of experience required | 16.1% | 38.4% | 0% |
| recruiter's average candidate review time | 33.0% | 79.0% | 0% |
| applicant feedback about the recruiter | 20.0% | 47.8% | 0% |

**Recruiter profiles** (n=90): location 100%, LinkedIn 77.8%, any link 78.9%,
current position 73.3%, picture 72.2%, headline 70%, summary 68.9%, top skills 71.1%,
languages 85.6%, current employer website 50% (its domain 45.6%: a second domain for
the email pattern when the job post has none), work history descriptions 62.2%.

Every full job page also says whether Torre flags the recruiter as **inactive**
(`talentSeekerInactive`, 1.2% of posts: skip them, nobody will answer).

Without the full job page (`scrapeDetails: false`) a row still has title, company,
salary, skills, locations and time zones from the search, at $3 per 1,000; website,
domain, description and hiring team need the full job page.

***

### Pricing

Pay per event. You only pay for rows delivered.

| Event | Price | When |
|---|---|---|
| Job post | $0.003 | every job row |
| Full job page | $0.008 | job rows with `scrapeDetails` (default on) |
| Recruiter profile | $0.01 | once per person per run (`includeRecruiterProfile`, always in `recruiters`) |
| Company email pattern | $0.01 | once per domain per run, **only when backed by real emails found on Torre** |
| Actor start | $0.00001 | platform minimum |

Real runs on Apify (2 Oct 2026):

| Run | Rows | Charged |
|---|---|---|
| Default input (`{}`): 20 remote software engineer jobs with full pages | 20 | **$0.22** |
| Prefill: 50 jobs (3 roles) with full pages and email pattern | 50 | **$0.55** (40 email patterns were guesses: free) |
| 400 LATAM jobs with full pages, recruiter profiles and email pattern | 400 | **$4.94** (400 jobs + 400 pages + 52 profiles + 2 patterns) |
| 15 recruiters (`outputType: recruiters`) | 15 | **$0.15** |
| 150 Colombia jobs, search only (`scrapeDetails: false`) | 150 | **$0.45** |

Rule of thumb: 100 job posts with full pages = **$1.10**; 1,000 search-only job posts = **$3**.
Duplicates within a run, error rows and failed pages are never charged. The run
stops cleanly at the maximum cost you set.

***

### Input

| Field | Default | Notes |
|---|---|---|
| `outputType` | `jobs` | `jobs` or `recruiters` |
| `jobUrls` | `[]` | optional: Torre job links or ids to enrich instead of searching (up to 5,000); the filters below are then ignored |
| `roles` | `["software engineer"]` | roles or skills, any of them; empty = all |
| `remoteOnly` | `true` | off = also on-site and hybrid jobs near the main cities (slower, by city) |
| `status` | `open` | `open`, `closed` or `any` |
| `countries` | `[]` | located in, or open to, these countries (remote jobs open to a country included) |
| `jobTypes` | `[]` | full-time, part-time (also covers freelance and flexible, same results on Torre), internships |
| `organizations` | `[]` | company names as shown on Torre |
| `minMonthlyCompensationUsd` | `0` | 0 = no minimum |
| `maxItems` | `20` | rows to deliver |
| `scrapeDetails` | `true` | full job page: website, domain, description, team |
| `includeRecruiterProfile` | `false` | LinkedIn, location, summary of the person who posted |
| `inferEmailPattern` | `false` | company email format from DNS |
| `includePersonalEmails` | `false` | |
| `includeEuRecruiters` | `false` | include people located in the EU/EEA/UK/CH (see Privacy) |

Example:

```json
{
  "roles": ["backend developer", "full stack developer"],
  "remoteOnly": true,
  "countries": ["Colombia", "Mexico"],
  "maxItems": 100,
  "includeRecruiterProfile": true
}
```

***

### Email pattern: what it is and what it is not

With `inferEmailPattern`, each row gets `emailPattern`: the company domain's MX
records, its email provider (Google Workspace, Microsoft 365…), the most likely
format (`first.last`, `first`, `flast`…) with a confidence score, and a guessed
email for each person on the hiring team.

- **DNS only.** No email is ever sent, and addresses are never "verified" by talking
  to the mail server (no SMTP probing), so `catchAll` is always `null`.
- **Torre publishes almost no emails** (2.1% of job descriptions). On 1 Oct 2026,
  **all 45 domains measured** had no email evidence: the format was guessed from
  the email provider, with **confidence 0.10** and `inferred: true`. Those guesses
  are **free**. You are only charged when the format is backed by emails actually
  found on Torre for that domain.
- 42 of 45 domains had valid MX records; providers: Google Workspace 21, Microsoft
  365 13, Proofpoint 6.

Treat `candidates` as hypotheses to verify, not as verified addresses.

***

### Privacy

- **Torre never publishes anyone's email**, and this actor never guesses personal
  addresses outside the company domain.
- Emails written in job descriptions are delivered when they are on a company
  domain; personal-domain addresses (gmail, outlook, yahoo…) only with
  `includePersonalEmails`. Without it they are also replaced by
  `[personal email hidden]` inside the description texts (counted in
  `enrichment.personalEmailsHidden` of `RUN_SUMMARY`).
- **People located in the EU, EEA, UK or Switzerland** (4.4% of profiles measured)
  are left out unless you turn on `includeEuRecruiters`. To know where someone is,
  the actor reads the public Torre profile of **every person it delivers** (who
  posted the job and the visible hiring team), once per person per run. Reading it
  for this check is **not charged**; the "Recruiter profile" event is only charged
  when you turn on `includeRecruiterProfile`. In job rows, an EU person keeps the
  shape of the row with every personal field set to `null` and `euRedacted: true`.
  If a profile cannot be read or has no country, the location is unknown and the
  person is delivered (counted in `enrichment.locationUnknown` of `RUN_SUMMARY`).
- Team members Torre hides on the public job page are never delivered. Screening
  messages written by candidates are never delivered (only their count). Profile
  locations come without coordinates.

***

### Output example (job post, shortened)

The structure is copied from a real run on Apify (2 Oct 2026); names and companies
are replaced with fictional ones.

```json
{
  "rowType": "job",
  "opportunityId": "AbCd1234",
  "url": "https://torre.ai/post/AbCd1234-acme-labs-senior-backend-engineer",
  "title": "Senior Backend Engineer",
  "status": "open",
  "remote": true,
  "locationType": "remote_countries",
  "countries": ["Colombia", "Mexico"],
  "applicantLocationRequirements": ["Colombia", "Mexico"],
  "compensation": { "code": "range", "currency": "USD", "min": 4000, "max": 6000, "periodicity": "monthly", "minHourlyUSD": 25, "maxHourlyUSD": 37.5, "visible": true },
  "skills": [{ "name": "Node.js", "proficiency": "expert", "experience": "potential-to-develop" }],
  "organization": { "name": "Acme Labs", "size": 40, "website": "https://www.example.com", "domain": "example.com", "websiteKind": "company" },
  "domain": "example.com",
  "postedBy": { "name": "Jane Doe", "username": "janedoe", "headline": "Talent Partner at Acme Labs", "profileUrl": "https://torre.ai/janedoe", "isTorreAccount": false, "profile": { "linkedinUrl": "https://www.linkedin.com/in/janedoe", "location": { "country": "Colombia", "countryCode": "CO", "city": "Bogota, Colombia", "timezone": "America/Bogota" } } },
  "members": [{ "name": "John Roe", "headline": "Co-Founder & CTO", "isManager": true, "isTorreAccount": false }],
  "postedByTorre": false,
  "talentSeekerInactive": false,
  "externalApplicationUrl": null,
  "descriptionText": "Responsibilities: …",
  "reputation": { "organizationRating": 4.6, "organizationJobsPosted": 12 },
  "emailPattern": { "domain": "example.com", "pattern": "first.last", "confidence": 0.1, "inferred": true, "mxValid": true, "emailProvider": "Google Workspace", "candidates": [{ "fullName": "Jane Doe", "email": "jane.doe@example.com", "confidence": 0.1, "inferred": true }], "catchAll": null },
  "detailScraped": true,
  "scrapedAt": "2026-10-01T23:30:00.000Z"
}
```

Every key is always present (`null` when Torre has no value), so CSV and Excel
exports keep the same columns.

***

### FAQ

**Why so few open "software engineer" jobs?** Torre's search mixes open and closed
posts. Measured on 1 Oct 2026: 65 of 2,813 remote "software engineer" posts were
open. Add more roles (backend, full stack, data engineer…), drop `remoteOnly`, or set
`status` to `any` to include closed posts, which still tell you who hires.

**Does it return every job on Torre?** Remote jobs: practically all of them (65 of
65 remote "software engineer" posts, measured). On-site jobs: those near the main
cities of each country (see "How the search works"); Torre no longer offers a search
without that location context. If you already have the job links, use `jobUrls`.

**Can I enrich my own list of jobs?** Yes: put Torre job URLs (or ids) in `jobUrls`.
Each one gets the full job page, team, company domain and, if you turn them on, the
recruiter profile and email pattern. Links that no longer exist are reported and
never charged.

**Why is "posted by" a Torre account on some jobs?** Torre aggregates jobs from
other sites (58.2% of open posts). Those rows have `postedByTorre: true` and an
`externalApplicationUrl`; use the hiring team (`members`) or the company domain.

**Do I get the recruiter's email?** Torre does not publish emails. You get their
public profile, LinkedIn (77.8%) and, with `inferEmailPattern`, a guessed company
email clearly marked with its confidence.

**Do I need a proxy?** No. On 2 Oct 2026, about 1,100 requests from Apify's own servers
(13 runs, up to 6 at the same time) got 0 refusals and never needed the fallback
proxy. The actor has its own fallback if a request is ever refused.

**How do I export the data?** From the run's Output tab as CSV, Excel, JSON or XML,
or with the Apify API, a schedule, a webhook, or integrations such as Make, Zapier,
n8n and Google Sheets. Every key is always present, so spreadsheet columns stay stable.

**How fast is it?** Measured on Apify on 2 Oct 2026 (512 MB, peak memory under 90 MB):
20 job posts with full pages in 6 s; 50 with full pages and email pattern in 9 s; 400
with full pages, recruiter profiles and email pattern in 80 s; 150 Colombia jobs
(search only) in 9 s. All 3,272 open jobs for Colombia (remote and on-site, search
only): about 66 s (measured locally on 2 Oct).

**Can I resume a long run?** Yes. If the platform migrates the run, it continues
from the same part and page of the search without delivering or charging any row twice.

# Actor input Schema

## `outputType` (type: `string`):

One row type per run. "Job posts" = one row per job with the company, salary, skills and the recruiter who posted it. "Recruiters" = one row per company person who publishes jobs (deduplicated), with their public profile, LinkedIn and the jobs they posted.

## `jobUrls` (type: `array`):

Skip the search and enrich exactly these Torre job posts: links like https://torre.ai/post/2wzYYqmW-company-role, or just the job id. Each one gets the full job page, the hiring team, the company website and domain and, if turned on, the recruiter profile and email pattern. When set, the search filters below are ignored. Up to 5,000. Links outside torre.ai are rejected.

## `roles` (type: `array`):

Job roles or skills to search, matched like the Torre search box (e.g. "software engineer", "backend developer", "data engineer", "python"). Several = any of them. Empty = all job posts. Results come in Torre's relevance order.

## `remoteOnly` (type: `boolean`):

Only remote job posts (2,617 open remote posts on 2 Oct 2026). Turn off to also search on-site and hybrid jobs near the main cities of the countries you choose (or of all covered countries): slower, and on-site coverage is by city (about 30-50 km around each one), not exhaustive.

## `status` (type: `string`):

Open jobs only (default) or also closed ones. Measured 1 Oct 2026: of 2,813 remote "software engineer" posts on Torre only 65 were open; closed posts are still useful to find companies that hire and their recruiters.

## `countries` (type: `array`):

Jobs located in, or open to candidates from, these countries. Remote jobs open to a country are included. With "Remote only" off, on-site jobs are searched around the main cities of each country. Empty = anywhere.

## `jobTypes` (type: `array`):

Empty = all. On Torre, "part-time" also covers freelance and flexible jobs (same results, measured).

## `organizations` (type: `array`):

Only job posts from these companies (name as shown on Torre). Empty = all companies.

## `minMonthlyCompensationUsd` (type: `integer`):

Only job posts whose pay range reaches at least this amount per month, in USD (Torre converts other currencies). 0 = no minimum. Job posts that hide their pay are excluded by Torre when this is set.

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

Maximum job posts (or recruiters) to deliver. You are charged per row delivered.

## `scrapeDetails` (type: `boolean`):

Adds the full description, company website and domain (95.8% of job posts), the hiring team, languages, contract type, application link and company reputation. One extra request and one "Full job page" charge per job post. Needed for the domain and the email pattern.

## `includeRecruiterProfile` (type: `boolean`):

Adds the public Torre profile of the person who posted each job: location, LinkedIn (77.8% of profiles) and other links, summary, current position, languages and top skills. Charged once per person. Always on for "Recruiters".

## `inferEmailPattern` (type: `boolean`):

Adds the likely company email format (e.g. first.last@example.com) with a confidence score, MX records and email provider, plus the guessed email of each recruiter. DNS only: no email is ever sent or verified by SMTP. Charged once per domain only when the pattern is backed by real emails found on Torre; guesses from the email provider alone (most Torre domains) are free and flagged inferred.

## `includePersonalEmails` (type: `boolean`):

Emails found in job descriptions are delivered when they are on a company domain. Personal-domain emails (gmail, outlook, yahoo…) are left out, and hidden inside the description texts, unless you turn this on.

## `includeEuRecruiters` (type: `boolean`):

People whose Torre profile places them in the EU, EEA, UK or Switzerland (4.4% of profiles measured) are left out unless you turn this on and have a lawful basis to process their data. The actor reads the public profile of every person it delivers to check this (free; the profile itself is only delivered and charged with "Recruiter profile"). If the profile cannot be read, the location is unknown and the person is delivered.

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

Job pages fetched in parallel. 4 is fast and gentle (no refusals measured up to 24).

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

Optional. Torre does not need a proxy; the actor has its own fallback if a request is refused. Leave empty.

## Actor input object example

```json
{
  "outputType": "jobs",
  "jobUrls": [],
  "roles": [
    "software engineer",
    "backend developer",
    "full stack developer"
  ],
  "remoteOnly": true,
  "status": "open",
  "countries": [],
  "jobTypes": [],
  "organizations": [],
  "minMonthlyCompensationUsd": 0,
  "maxItems": 50,
  "scrapeDetails": true,
  "includeRecruiterProfile": false,
  "inferEmailPattern": true,
  "includePersonalEmails": false,
  "includeEuRecruiters": false,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per job post (title, company, domain, salary, skills, recruiter) or per recruiter (profile, LinkedIn, jobs posted), plus the email pattern when requested.

## `runSummary` (type: `string`):

Counts delivered and charged, enrichment counts, network summary and whether the run stopped early.

## `errors` (type: `string`):

Job pages or profiles that could not be read and input adjustments (always written, empty when all went well). Never charged.

# 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 = {
    "roles": [
        "software engineer",
        "backend developer",
        "full stack developer"
    ],
    "maxItems": 50,
    "inferEmailPattern": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/torre-jobs-recruiters-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 = {
    "roles": [
        "software engineer",
        "backend developer",
        "full stack developer",
    ],
    "maxItems": 50,
    "inferEmailPattern": True,
}

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/torre-jobs-recruiters-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 '{
  "roles": [
    "software engineer",
    "backend developer",
    "full stack developer"
  ],
  "maxItems": 50,
  "inferEmailPattern": true
}' |
apify call oswaldocarabano/torre-jobs-recruiters-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oswaldocarabano/torre-jobs-recruiters-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/leUCd0MkBEZpqfrc8/builds/ayCeC8hUWJjFdhzCp/openapi.json