# Gupy Jobs Scraper - Brazil Vagas, Details & Employer Contacts (`topapi/gupy-jobs-scraper`) Actor

Scrape Gupy jobs in Brazil: title, company, city, state, remote/hybrid, job type, PcD, dates, full text, requirements, benefits, hiring steps, company page, employer emails and CNPJ. Every portal filter, company career sites, links, monitor mode. $0.40 per 1,000 jobs.

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

## Pricing

from $0.40 / 1,000 jobs

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

### What does Gupy Jobs Scraper do?

**Gupy Jobs Scraper** exports Gupy jobs in Brazil (vagas from portal.gupy.io and every company's `<company>.gupy.io`
career site) to JSON, CSV or Excel, with no Gupy account and no cookies. Each row is one job: title, company, city and
state, remote / hybrid / on-site, job type (Efetivo/CLT, Estágio, Aprendiz, PJ, Temporário, Banco de talentos...), PcD,
published date and deadline, the whole posting text, and by default the job's full record from the company's career site:
requirements, responsibilities, benefits, hiring steps, full address and ZIP, job code, hiring reason and the company page
(about, website, LinkedIn, Instagram, Facebook, Glassdoor). Optional **employer contacts** read the employer's own website
for emails, phones and its **CNPJ** with the Receita Federal record.

Also called: Gupy API, Gupy jobs API, Gupy vagas scraper, Brazil jobs scraper, vagas de emprego API.

- Search like on portal.gupy.io: keyword, state, city, workplace type, job type, company, PcD, Gupy's feedback badge.
  **Gupy applies these filters itself**, so the counts are exact and runs are fast.
- Paste links: portal searches (`/job-search/...`, `/vagas/<term>`), career sites (`https://farm.gupy.io/`) or single jobs.
- Company inputs return the company's portal jobs **plus the jobs only its career site lists** (FARM: 383 on its site, 381 on the portal).
- **Newest first**, date windows, **only new jobs** on a schedule, **company rows** (open jobs, mixes, change since the last run),
  hiring companies of a search, and alerts to Slack, Discord, Teams, Telegram, ntfy, WhatsApp or a webhook.
- Reads past Gupy's 10,000-jobs-per-search limit (22,735 of 22,823 permanent on-site jobs in São Paulo in one run).

### What data can you get from Gupy?

| Job (every row) | Job record (on by default) | Company and contacts |
|---|---|---|
| 💼 Title, job id, job link, portal link | 📋 Requirements, responsibilities, benefits / additional info | 🏢 Company name, career site, logo, banner |
| 📍 City, state, UF, country | 🪜 Hiring steps in order (name, type, category) | 📝 About the company |
| 🏠 Remote / hybrid / on-site | 🏷️ Job code, hiring reason, publication type | 🌐 Website, LinkedIn, Instagram, Facebook, Glassdoor |
| 📄 Job type, contract (CLT, PJ, Estágio...) | 🗺️ Full address and ZIP (CEP) | 📧 Employer emails, phones, socials (add-on) |
| ♿ PcD flag and badge | ⏳ Register end date, expiry, quick apply | 🧾 CNPJ, legal name, size, CNAE, status (add-on) |
| 📅 Published date, days since, deadline | ❓ Application questions, video, pictures | 📊 Company rows: open jobs and mixes |
| 🎚️ Seniority, skills, salary, English, benefit tags | | |

### How to scrape Gupy with Gupy Jobs Scraper

1. Type keywords (or paste links, or company names) in **What to scrape**.
2. Narrow with **Gupy's filters** (state, city, workplace type, job type, PcD...). They are free.
3. Set **Max rows** and click **Start**. Download the rows as JSON, CSV, Excel or HTML, or read them through the API.

### ⬇️ Input

| Input | What it does |
|---|---|
| `searchQueries` | Job title words, one search each (`analista`, `desenvolvedor`, `vendedor`). Any case and accents. Empty = the newest jobs on the whole portal. |
| `companies` | Company names as Gupy shows them (`Itaú Unibanco`, `Compass UOL`), subdomains (`vemproitau`) or career-site links. |
| `startUrls` | Portal search links (their filters are read), `/vagas/<term>` links, career sites, job links (`/jobs/<id>` or `/job/<code>`). |
| `states` | Names or UF codes (`SP`, `Minas Gerais`); one search per state. |
| `cities` | Any spelling (`sao paulo`, `Recife - PE`); matched to the 5,571 IBGE municipalities. |
| `workplaceTypes` | `remote`, `hybrid`, `on-site`. |
| `jobTypes` | Gupy's 16 job types; `CLT`, `PJ`, `estágio`, `aprendiz` also work over the API. |
| `pwdOnly`, `friendlyBadgeOnly` | PcD jobs only; companies with Gupy's feedback badge only. |
| `sortBy` | `newest` (default), `oldest`, `relevance`, `company`, `fewApplications`. |
| `postedWithin`, `dateFrom`, `dateTo` | Date window; reading stops at the first older job. |
| `excludeTalentPool`, `titleInclude`, `titleExclude`, `excludeKeywords`, `companyContains`, `companyExclude`, `seniorities`, `locationKeywords`, `departmentIncludes`, `minSalary`, `withSalaryOnly`, `skipIds` | Filters the actor applies before any charge. |
| `includeDetails` | The full job record (default on). |
| `includeCompanyContacts`, `withEmailOnly` | Employer emails, phones, socials and the CNPJ record. |
| `descriptionFormat`, `descriptionMaxLength` | `text`, `html`, `markdown`, `both`, `all`, `none`. |
| `trackCompanies`, `mode`, `maxJobsScanned` | Company rows instead of job rows. |
| `monitorMode`, `monitorStoreName`, `emitBaseline`, `includeUpdated`, `includeRemoved`, `includeUnchanged`, `resetMonitor` | Only new jobs on a schedule. |
| `maxItems`, `maxItemsPerSearch`, `maxPages`, `splitLargeSearches`, `maxConcurrency` | How much to read. `maxItems: 0` = no limit. |
| Alerts | `telegramToken` + `telegramChatId`, `slackWebhookUrl`, `discordWebhookUrl`, `teamsWebhookUrl`, `ntfyTopic`, WhatsApp Cloud API, `webhookUrl`. |
| `proxyConfiguration` | Not needed; Gupy answers a direct connection. |

Input names used by other Gupy actors are accepted too (`searchTerms`, `keywords`, `termo`, `state`, `city`, `workplaceType`,
`jobType`, `vacancyTypes`, `pcdOnly`, `onlyFeedbackCompanies`, `postedWithinDays`, `includeDescription`, `onlyNew`,
`watchName`, `maxResults`, `empresas`, `subdomains`, `careerPageUrls`...).

#### Input JSON

```json
{
  "searchQueries": ["analista de dados", "desenvolvedor"],
  "states": ["SP"],
  "workplaceTypes": ["remote", "hybrid"],
  "jobTypes": ["vacancy_type_effective"],
  "postedWithin": "7d",
  "maxItems": 200
}
```

#### One idea per keyword

Gupy matches the words of the job title. `analista` finds 6,851 jobs; `analista de dados` 214. Put each title in its own
line rather than one long phrase.

#### Paste a link when you already searched on the site

`https://portal.gupy.io/job-search/term=analista&state=Minas%20Gerais&workplaceTypes[]=hybrid` runs that exact search.

### ⬆️ Output

A real row (40-row run with employer contacts, 2026-11-07; long text cut here):

```json
{
  "type": "job",
  "id": 12851634,
  "title": "Engenheiro(a) de Qualidade Sênior (QE)",
  "careerPageName": "+A Educação Tech",
  "jobUrl": "https://maisaedu-tech.gupy.io/jobs/12851634",
  "location": "Remoto",
  "workplaceType": "remote",
  "jobType": "vacancy_type_effective",
  "jobTypeLabel": "Efetivo",
  "contractType": "CLT",
  "seniority": "senior",
  "publishedDate": "2026-11-06T21:18:59.767Z",
  "applicationDeadline": "2027-01-25T00:00:00.000Z",
  "disabilities": true,
  "skills": ["ci/cd", "cypress", "typescript", "javascript", "python", "c#", "java", "docker"],
  "benefitTags": ["meal_voucher", "health_plan", "dental_plan", "life_insurance", "gym", "remote_allowance", "education"],
  "prerequisites": "- Experiência sênior em Engenharia de Qualidade, Arquitetura de Testes ou Engenharia de Software com foco em qualidade;\n- Experiência na criação ou evolução de …",
  "hiringSteps": ["Cadastro", "Entrevista com RH", "Entrevista com Gestão + Teste Técnico", "Proposta", "Contratação"],
  "code": "1850-12851634",
  "careerPageWebsite": "https://maisaedu.com.br/",
  "companyLinkedin": "https://www.linkedin.com/company/maisaedu",
  "employerEmail": "sac@grupoa.com.br",
  "employerPhones": ["08007033444"],
  "cnpj": "87.133.666/0001-04",
  "companyLegalName": "GA EDUCACAO S.A.",
  "companySizeBracket": "DEMAIS",
  "companyActivity": "Comércio varejista de livros",
  "companyRegistryStatus": "ATIVA",
  "detailStatus": "ok"
}
```

A company row (`trackCompanies: ["Compass UOL"]`):

```json
{ "type": "company", "careerPageName": "Compass UOL", "careerPageUrl": "https://compass.gupy.io/", "openJobs": 26, "openJobsOnPortal": 25,
  "workplaceMix": { "remote": 21, "hybrid": 5 }, "jobTypeMix": { "Efetivo": 24, "Temporário": 1, "Banco de talentos": 1 },
  "stateMix": { "SP": 5 }, "newestPostingAt": "2026-11-06T12:25:51.978Z", "hasFriendlyBadge": true }
```

#### Fields and how often they are filled

Measured on a 1,000-row run (`analista`, 568 companies, 2026-11-07): id, title, company, job link, workplace type, job
type, published date, deadline, PcD flag and description 100%; city / state 93.5% (remote jobs have none); requirements
98.5%, responsibilities 97.9%, benefits section 92.7%, hiring steps 99.5%, address 99.5%, ZIP 91.3%, hiring reason 85.1%;
company website 77.0%, LinkedIn 78.1%, Instagram 68.5%, Facebook 45.6%, Glassdoor 27.8%; seniority 66.4%, skills 86.3%,
benefit tags 82.3%, salary 4.0% (most Gupy postings publish none). Employer contacts (40-row run, 33 companies): 28 had a
website, 8 gave an email, 6 printed a CNPJ that the registry matched.

- `skills`, `seniority`, `salary*`, `requiresEnglish`, `englishLevel`, `benefitTags` are read from the posting's own text
  (Gupy's own skills field is empty on every record). Null when the text does not say.
- `department` and `addressDistrict` come from company career sites, so they are filled on rows found through `companies`.
- Gupy's portal also lists some partner-board jobs (vaga-ja.com): their `jobUrl` is the partner's page and they carry no
  job record (`detailStatus: partner_board`, not charged for details). Old records of career sites Gupy switched off have
  `careerPageInactive: true`.

### How much does it cost to scrape Gupy?

Pay per event, no start fee:

| Event | Price |
|---|---|
| Job row | $0.40 per 1,000 jobs |
| Job details (the full record) | $0.05 per 1,000 jobs that get it |
| Employer contacts | $0.0072 per company whose website gave an email (once per company per run) |
| Company row | $0.0072 per company row |

20 jobs with details cost $0.009; 1,000 jobs with details $0.45. Jobs removed by a filter, jobs delivered by an earlier
monitor run and searches that match nothing are not charged. Set a maximum charge on the run and it stops cleanly there.

### Run it on a schedule (only new jobs)

Turn on **Only new jobs** (`monitorMode: true`), give the schedule a **Monitor name**, and add an Apify schedule (for
example every hour). Each run reads newest first and stops at the first page of jobs it has already delivered; a run with
nothing new costs about $0.0001 and is not charged. `emitBaseline: false` makes the first run remember today's jobs without
delivering them. A job delivered without job details or employer contacts comes again once, with them and
`changeType: "details"`, when a later run of the same monitor turns them on (charged like any job with them). Alerts can push each run's new jobs to Slack, Discord, Teams, Telegram, ntfy, WhatsApp or your webhook.

```json
{ "searchQueries": ["analista de dados"], "states": ["SP"], "monitorMode": true, "monitorStoreName": "dados-sp", "slackWebhookUrl": "https://hooks.slack.com/services/..." }
```

Through the API: `POST https://api.apify.com/v2/acts/TopApi~gupy-jobs-scraper/run-sync-get-dataset-items?token=<your token>`
with the input as the JSON body. It also works as a tool for AI agents over Apify's MCP server.

### Speed and limits (measured 2026-11-06/07)

- 20 jobs with details: 2 s. 150 jobs (3 keywords): 3 s. 1,000 jobs with details: 8-162 s (the first ~10 s of a run get a full CPU). 3,000 jobs with details: 504 s.
  10,836 jobs without details: 102 s; 22,735 jobs without details: 354 s.
- Gupy shows at most 10,000 jobs per search. Past that the actor reads newest-first and oldest-first halves (up to 20,000),
  then splits by state, job type, workplace type and city: 22,735 of 22,823 jobs in the largest test.
- Some jobs are shown only to signed-in candidates; their links end with "not found or private" and are not charged.
- Employer websites that block automated visits, or publish no email, give no contacts (not charged).
- Gupy's portal lists jobs by title words; it does not search inside descriptions.

### FAQ

**Do I need a Gupy account or a proxy?** No. The actor reads the same public pages a visitor sees.

**Where do the contacts come from?** Only from the employer's own website as its Gupy career page lists it, and the CNPJ
from that site, looked up in the Receita Federal's open CNPJ data. Partners' names are never collected.

**Can I get every job of one company?** Yes: put its name, subdomain or career-site link in `companies`, `maxItems: 0`.

**Why do some rows have no record?** Partner-board jobs, jobs of career sites Gupy switched off, and private jobs have no
public record; the row says why in `detailStatus` and is not charged for details.

# Actor input Schema

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

Job title words, one per line: analista, desenvolvedor, vendedor, enfermeiro, estágio. Each keyword is one Gupy search (Gupy matches job titles, any case and accents). Empty = every job matching the filters below, or the whole portal (about 83,000 open jobs). API aliases: searchTerms, keywords, query, termo.

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

Company names as Gupy shows them (Itaú Unibanco, Compass UOL, FARM), career-site subdomains (vemproitau, compass, farm) or career-site links (https://farm.gupy.io/). Returns the company's portal jobs plus the jobs only its career site lists. API aliases: companyNames, empresas, subdomains, careerPageUrls.

## `startUrls` (type: `array`):

Gupy links: portal searches (https://portal.gupy.io/job-search/term=analista\&state=São Paulo\&workplaceTypes\[]=remote, https://portal.gupy.io/vagas/analista-de-dados), career sites (https://farm.gupy.io/) or single jobs (https://farm.gupy.io/jobs/12848694, https://farm.gupy.io/job/eyJqb2JJZCI6...). The filters below are added to search links. API aliases: searchUrls, jobUrls, urls.

## `states` (type: `array`):

Brazilian states by name or code: São Paulo, SP, Minas Gerais, RJ. Accents optional. One search per state. Remote jobs are published without a state, so a state leaves them out. API alias: state.

## `cities` (type: `array`):

Cities, any case and accents: sao paulo, Campinas, Belo Horizonte, Recife - PE. Names are matched to the 5,571 IBGE municipalities and sent to Gupy in its spelling. Several cities = jobs in any of them. API alias: city.

## `workplaceTypes` (type: `array`):

Remote, hybrid, on-site, or several. Empty = all. API aliases: workplaceType, remoteOnly.

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

Gupy's job types; several at once. Empty = all. API aliases: jobType, vacancyTypes, contractType (CLT, PJ, estágio, aprendiz...).

## `pwdOnly` (type: `boolean`):

Only jobs the employer opened to PcD candidates (Gupy's own filter). API aliases: pcdOnly, onlyOpenToPwd.

## `friendlyBadgeOnly` (type: `boolean`):

Only companies with Gupy's 'Selo Feedback' (they answer every candidate). API alias: onlyFeedbackCompanies.

## `sortBy` (type: `string`):

Gupy's own order. Newest first lets date windows and monitor runs stop early.

## `postedWithin` (type: `string`):

Only jobs published in this window (reading stops at the first older job). API alias: postedWithinDays (a number).

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

YYYY-MM-DD. API aliases: postedAfter, sinceDate.

## `dateTo` (type: `string`):

YYYY-MM-DD. API alias: postedBefore.

## `excludeTalentPool` (type: `boolean`):

Gupy's 'Banco de talentos' postings collect CVs for future openings (about 13% of the portal).

## `titleInclude` (type: `array`):

Keep a job only when its title contains one of these words (any case and accents). API alias: titleKeywords.

## `titleExclude` (type: `array`):

Drop jobs whose title contains one of these words.

## `excludeKeywords` (type: `array`):

Drop jobs whose title or text contains one of these words.

## `companyContains` (type: `array`):

Keep jobs whose company name contains one of these words.

## `companyExclude` (type: `array`):

Drop jobs whose company name contains one of these words.

## `seniorities` (type: `array`):

Seniority read from the title (Júnior, Pleno, Sênior, Especialista, Coordenador...). API alias: experienceLevels.

## `locationKeywords` (type: `array`):

Keep jobs whose city, state or workplace label contains one of these words.

## `departmentIncludes` (type: `array`):

Keep jobs whose department contains one of these words (departments come from company career sites).

## `minSalary` (type: `integer`):

Keep jobs whose posted salary reaches this amount. Most Gupy postings publish no salary.

## `withSalaryOnly` (type: `boolean`):

Keep only jobs whose text gives a salary in R$.

## `skipIds` (type: `array`):

Gupy job ids you already have; never delivered or charged.

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

The full job record from the company's career site: requirements, responsibilities, benefits, hiring steps, full address and ZIP, job code, hiring reason, expiry, quick apply, application questions, video, and the company page (about, website, LinkedIn, Instagram, Facebook, Glassdoor). One request per job; charged as a job-details event per job that gets it.

## `includeCompanyContacts` (type: `boolean`):

Emails, phones and social profiles from the employer's own website (as its Gupy career page lists it), plus the CNPJ the site prints with its Receita Federal record (legal name, size, CNAE activity, status). Charged once per company per run, only when an email is found. API aliases: enrichContacts, enrichEmails.

## `withEmailOnly` (type: `boolean`):

With employer contacts on: drop jobs whose employer website gave no email (not charged).

## `descriptionFormat` (type: `string`):

How the posting text comes out. API alias: includeDescription false = none.

## `descriptionMaxLength` (type: `integer`):

0 = full text.

## `trackCompanies` (type: `array`):

Company names, subdomains or career-site links: one row each with open jobs, workplace / job type / seniority / state / city / department mix, newest posting, the company page and, on later runs, the change (new and closed job ids). Charged per company row.

## `mode` (type: `string`):

Hiring companies: the keyword / filter search above, read up to 'Jobs scanned', grouped into one row per company (matching jobs, all open jobs on its career site, mixes, company page).

## `maxJobsScanned` (type: `integer`):

How many jobs the search reads before grouping them by company. Scanning is not charged.

## `monitorMode` (type: `boolean`):

Remembers the jobs of earlier runs with the same search and monitor name and returns only new ones, newest first. Reading stops at the first page of known jobs; a run with nothing new costs almost nothing and writes nothing. A job delivered earlier without the job details or employer contacts that a later run turns on comes again once with them, as changeType 'details'. API aliases: onlyNew, newOnly, onlyNewJobs.

## `monitorStoreName` (type: `string`):

Separate memories for separate schedules. API aliases: watchName, monitorName, stateName.

## `emitBaseline` (type: `boolean`):

Off = the first run only remembers today's jobs (nothing delivered or charged) and later runs return what is new.

## `includeUpdated` (type: `boolean`):

Jobs delivered before whose title, place, type, deadline or text changed come again with changeType 'updated'.

## `includeRemoved` (type: `boolean`):

Jobs from earlier runs that left this search come as a short row with changeType 'removed'. Needs a full read of the search on every run.

## `includeUnchanged` (type: `boolean`):

Return every current job, each marked new, updated, unchanged or details.

## `resetMonitor` (type: `boolean`):

Start the monitor memory over.

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

Jobs (or company rows) in total. 0 = no limit. API aliases: maxResults, maxJobs.

## `maxItemsPerSearch` (type: `integer`):

Cap for each keyword / state / company search. API alias: maxResultsPerSearch.

## `maxPages` (type: `integer`):

Gupy pages (100 jobs each) per search.

## `splitLargeSearches` (type: `boolean`):

Gupy shows at most 10,000 jobs per search. On: newest-first and oldest-first halves, then the search is split by state, job type, workplace type and city to reach every job.

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

Job records read at once.

## `telegramToken` (type: `string`):

Bot token from @BotFather; with a chat id, each run sends its new jobs there.

## `telegramChatId` (type: `string`):

The chat, group or channel id.

## `slackWebhookUrl` (type: `string`):

An incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

A channel webhook URL.

## `teamsWebhookUrl` (type: `string`):

An incoming-webhook URL.

## `ntfyTopic` (type: `string`):

A topic on ntfy.sh (or your server).

## `whatsappAccessToken` (type: `string`):

With a phone number id and a recipient.

## `whatsappPhoneNumberId` (type: `string`):

Your WhatsApp Business phone number id.

## `whatsappTo` (type: `string`):

Number in international format.

## `webhookUrl` (type: `string`):

POST with the new jobs as JSON.

## `notificationLimit` (type: `integer`):

How many jobs each alert lists.

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

Not needed: Gupy answers a direct connection, and the actor moves to the Apify datacenter proxy by itself if Gupy refuses it. Set one only to send everything through your own proxy.

## Actor input object example

```json
{
  "searchQueries": [
    "analista"
  ],
  "pwdOnly": false,
  "friendlyBadgeOnly": false,
  "sortBy": "newest",
  "postedWithin": "any",
  "excludeTalentPool": false,
  "withSalaryOnly": false,
  "includeDetails": true,
  "includeCompanyContacts": false,
  "withEmailOnly": false,
  "descriptionFormat": "text",
  "mode": "jobs",
  "maxJobsScanned": 1000,
  "monitorMode": false,
  "monitorStoreName": "gupy-monitor",
  "emitBaseline": true,
  "includeUpdated": false,
  "includeRemoved": false,
  "includeUnchanged": false,
  "resetMonitor": false,
  "maxItems": 20,
  "splitLargeSearches": true,
  "maxConcurrency": 10,
  "notificationLimit": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per job (or per company): title, company, city, state, workplace type, job type, PcD, dates, the whole posting, requirements, benefits, hiring steps, company page, employer contacts and CNPJ record.

## `summary` (type: `string`):

Per-search counts (on Gupy, read, delivered), filters, job records and egress (written for Console runs, large runs and runs with a problem).

# 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": [
        "analista"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/gupy-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 = {
    "searchQueries": ["analista"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/gupy-jobs-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": [
    "analista"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call topapi/gupy-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/gupy-jobs-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/MxFMaU3beauHbVgAm/builds/goFPwVUdQCZYJvgFV/openapi.json
