# Bumeran Jobs Scraper (`automation-lab/bumeran-jobs-scraper`) Actor

Search public Bumeran-family job boards in seven LATAM countries and extract normalized vacancy details for analysis and monitoring.

- **URL**: https://apify.com/automation-lab/bumeran-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 bumeran jobs

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Bumeran Jobs Scraper

Collect current **Bumeran jobs** from seven public LATAM job-board sites in one normalized dataset.

Bumeran Jobs Scraper searches vacancies, opens each job detail, and returns stable job IDs, titles, employers, countries, locations, modality, dates, salary fields, structured requirements, descriptions, and canonical URLs.

Use it for recruiting research, regional vacancy feeds, spreadsheet exports, and scheduled monitoring without maintaining a separate parser for every country portal.

### What does Bumeran Jobs Scraper do?

The Actor supports these public Bumeran-family sites:

- Argentina — Bumeran (`bumeran.com.ar`)
- Chile — Laborum (`laborum.cl`)
- Ecuador — Multitrabajos (`multitrabajos.com`)
- Mexico — Bumeran (`bumeran.com.mx`)
- Panama — Konzerta (`konzerta.com`)
- Peru — Bumeran (`bumeran.com.pe`)
- Venezuela — Bumeran (`bumeran.com.ve`)

For every selected country, it:

1. Searches the public vacancy catalog.
2. Paginates until the requested limit is reached or results end.
3. Opens each vacancy through the source's public detail data route.
4. Normalizes country-specific fields into a shared schema.
5. Charges and saves only valid, unique vacancy records.

Specific public job URLs can also be extracted directly with `startUrls`.

### Who is this Bumeran jobs extractor for?

#### Recruiters and sourcing teams

Build a current pool of roles by keyword, country, employer, location, or modality.

#### Job aggregators

Feed stable IDs and canonical URLs into deduplication and publishing pipelines.

#### Labor-market analysts

Compare hiring activity, categories, contract types, and work modalities across LATAM markets.

#### Data and automation teams

Schedule recurring Apify Tasks and compare `jobId` plus `modifiedAt` between runs.

#### Researchers

Export structured vacancy data to CSV, Excel, JSON, or a database without parsing page markup.

### Why use this Actor?

- One input covers seven related LATAM portals.
- Every saved item includes the full public detail response, not only a search-card summary.
- Stable `jobId` values support deduplication and change tracking.
- `publishedAt`, `modifiedAt`, and `expiresAt` support incremental monitoring workflows.
- Country output is balanced when several countries are selected, so a large first market does not consume the entire limit.
- Direct HTTP and coherent source sessions keep memory and runtime lower than a browser-only scraper.
- Optional Apify Proxy settings are available for users who need a controlled network route.

The Actor does not apply to jobs, log in, or collect private applicant information.

### What Bumeran job data can I extract?

| Field | Meaning |
| --- | --- |
| `jobId` | Stable numeric vacancy identifier |
| `title` | Published job title |
| `employer`, `employerId` | Employer name and source ID when disclosed |
| `countryCode`, `country` | Normalized country identifiers |
| `location`, `province`, `city` | Published geographic fields |
| `modality` | Remote, hybrid, or on-site label when supplied |
| `employmentType` | Full-time, part-time, or another source type |
| `contractType` | Published contract arrangement |
| `seniority` | Published seniority level |
| `area`, `subArea` | Source job categories |
| `vacancies` | Number of openings when disclosed |
| `salaryMin`, `salaryMax` | Published salary bounds when available |
| `salaryFrequency`, `salaryType` | Source salary metadata |
| `publishedAt`, `modifiedAt`, `expiresAt` | Vacancy lifecycle timestamps |
| `description`, `descriptionHtml` | Plain-text and original HTML descriptions |
| `requirements` | Structured education, experience, salary, skill, and language requirements |
| `skills`, `languages`, `benefits` | Convenient normalized arrays |
| `jobUrl` | Canonical public vacancy URL |
| `scrapedAt` | Time the record was collected |

Many employers do not publish salary values, benefits, or every requirement.

Those fields are returned as `null` or an empty array rather than guessed.

### How to scrape Bumeran jobs

1. Open the Actor in Apify Console.
2. Choose one or more country codes.
3. Enter an optional keyword such as `desarrollador`, `ventas`, or `remoto`.
4. Choose newest-first or relevance sorting.
5. Set `maxItems` to the number of fully enriched jobs needed.
6. Click **Start**.
7. Open the default dataset to preview, download, or integrate the results.

A small first run is recommended before increasing the limit.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `countryCodes` | array | `["AR"]` | Country sites to search: AR, CL, EC, MX, PA, PE, or VE |
| `query` | string | empty | Optional keyword or phrase, maximum 120 characters |
| `startUrls` | array | `[]` | Specific supported public job detail URLs |
| `sort` | string | `recent` | `recent` for newest jobs or `relevant` for search relevance |
| `maxItems` | integer | `50` | Global output limit from 1 to 10,000 |
| `maxConcurrency` | integer | `4` | Concurrent detail requests, from 1 to 10 |
| `proxyConfiguration` | object | none | Optional Apify Proxy configuration |

At least one country code is required.

Explicit URLs are processed before search results and count toward the same `maxItems` limit.

Unsupported domains, malformed detail URLs, and invalid country codes fail the run with a clear error.

### Example inputs

#### Search developer jobs in Argentina

```json
{
  "countryCodes": ["AR"],
  "query": "desarrollador",
  "sort": "relevant",
  "maxItems": 10
}
```

#### Collect sales jobs from Bumeran Mexico

```json
{
  "countryCodes": ["MX"],
  "query": "ventas",
  "sort": "recent",
  "maxItems": 10
}
```

#### Monitor remote vacancies across four countries

```json
{
  "countryCodes": ["AR", "CL", "MX", "PE"],
  "query": "remoto",
  "sort": "recent",
  "maxItems": 20
}
```

The last input returns a balanced sample from all four selected country sites when enough matching jobs exist.

### Example Bumeran job output

This shortened example reflects current Actor output:

```json
{
  "jobId": "1118383446",
  "title": "Encargada de Marketing y Ventas",
  "employer": "Nifla",
  "countryCode": "MX",
  "country": "Mexico",
  "location": "Ciudad de México, Distrito Federal, Mexico",
  "modality": "Presencial",
  "employmentType": "Full-time",
  "publishedAt": "2026-07-31T02:02:27",
  "modifiedAt": "2026-07-31T10:21:09",
  "skills": [],
  "languages": [],
  "jobUrl": "https://www.bumeran.com.mx/empleos/encargada-de-marketing-y-ventas-nifla-1118383446.html",
  "scrapedAt": "2026-08-01T07:00:00.000Z"
}
```

The complete row also includes descriptions, structured requirements, salary fields, categories, contract details, and vacancy status.

### How much does it cost to scrape Bumeran jobs?

This Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each valid vacancy saved.

The current start fee is **$0.0005**.

At the BRONZE tier, each saved job is **$0.0008**.

Approximate BRONZE examples:

| Saved jobs | Approximate total |
| ---: | ---: |
| 10 | $0.0085 |
| 100 | $0.0805 |
| 1,000 | $0.8005 |

Higher Apify plan tiers receive the discounts configured in the Actor pricing table.

Only validated dataset items are charged as `item` events.

No separate event is charged for details, requirements, descriptions, or salary fields.

### Monitoring new and changed vacancies

Create an Apify Task with `sort: "recent"`, then add a schedule.

Use this downstream key:

```text
countryCode + ":" + jobId
```

For each key:

- a previously unseen key is a new vacancy;
- a changed `modifiedAt` value indicates a source update;
- an absent key may require confirmation over multiple runs before treating a vacancy as removed;
- `expiresAt` can help identify expected closure dates.

The Actor returns the data needed for incremental comparison.

It does not maintain a hidden cross-run database or suppress unchanged records.

This keeps every run reproducible and lets users control retention rules.

### Export and integration workflows

Results are stored in the default Apify dataset.

You can:

- download JSON, CSV, Excel, XML, or HTML;
- connect datasets to Google Sheets;
- send new rows through Make or Zapier;
- load jobs into BigQuery, Snowflake, PostgreSQL, or another warehouse;
- trigger webhooks when scheduled runs finish;
- compare snapshots in a data pipeline;
- build a normalized internal vacancy feed.

Use `jobId` for source-level identity and `jobUrl` for human review.

### API usage

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bumeran-jobs-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countryCodes":["AR","MX"],"query":"remoto","sort":"recent","maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bumeran-jobs-scraper').call({
  countryCodes: ['AR', 'MX'],
  query: 'remoto',
  sort: 'recent',
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/bumeran-jobs-scraper").call(run_input={
    "countryCodes": ["AR", "MX"],
    "query": "remoto",
    "sort": "recent",
    "maxItems": 20,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Bumeran Jobs Scraper with MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bumeran-jobs-scraper"
```

#### Claude Desktop

Add this server to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bumeran-jobs-scraper"
    }
  }
}
```

#### Cursor

Add the same JSON under Cursor **Settings → MCP** and enable the `apify` server.

#### VS Code

Add the same HTTP MCP server URL to your VS Code MCP configuration, then select the `automation-lab/bumeran-jobs-scraper` tool.

Example prompts:

- “Run Bumeran Jobs Scraper for remote developer roles in Argentina and Mexico, maximum 30 jobs.”
- “Collect the newest sales vacancies from Bumeran Mexico and summarize employers by city.”
- “Compare job IDs and modified dates from this run with yesterday's dataset.”

### Performance and proxy behavior

The Actor uses lightweight HTTP requests and a coherent cookie/token session for each country.

Default memory is 256 MB.

Detail concurrency defaults to four requests.

Increasing concurrency can improve speed, but overly aggressive values may raise upstream errors.

Direct public access is used when `proxyConfiguration` is omitted.

When a proxy is configured, its identity remains paired with that country's session cookies and tokens.

The Actor does not automatically switch to residential traffic, avoiding unexpected proxy spend.

### Limitations

- Bumeran-family sites can change endpoints, fields, anti-bot controls, or taxonomies.
- Search results reflect what each public country portal currently returns.
- Salary is often withheld, so salary fields may be null.
- Confidential listings may omit employer names.
- Text search relevance is determined by the source.
- Dates are normalized from source-local timestamps without inventing a timezone offset.
- Multi-country limits are balanced, not ranked globally across all countries.
- The Actor extracts public vacancy data; it does not submit applications.
- A successful no-result query produces an empty dataset.

For high limits, test a smaller run first and consider using a schedule rather than repeated manual runs.

### Responsible use and legality

Use this Actor only for lawful purposes and data you are authorized to process.

Public job listings can still contain personal or sensitive information in free-text descriptions.

Follow applicable privacy, employment, database, copyright, and anti-discrimination laws.

Respect source terms, reasonable request rates, and data-retention obligations.

Do not use output to send spam, discriminate against candidates, impersonate employers, or automate applications without authorization.

You are responsible for deciding whether your use case and jurisdiction permit collection and reuse.

### Troubleshooting

#### The dataset is empty

Check the query spelling, country selection, and source site manually.

Try a broader keyword or omit `query` to request recent vacancies.

An empty dataset is expected when the source reports no matches.

#### A specific URL fails validation

Use a full HTTPS public job detail URL from one of the seven supported domains.

The URL must end with the numeric job ID and `.html`.

Search pages and employer pages are not accepted as `startUrls`.

#### The source returns 403 or 429

Keep `maxConcurrency` at four or lower and retry later.

If your network route is restricted, configure Apify Proxy explicitly.

Do not rotate identity between bootstrap and detail requests.

#### Some fields are null

That means the source did not publish the value.

The Actor does not infer salaries, employer identities, or requirements.

### FAQ

#### Does it cover all Bumeran LATAM sites?

It supports the seven public sites listed above: Argentina, Chile, Ecuador, Mexico, Panama, Peru, and Venezuela.

#### Can I monitor only remote roles?

Use a query such as `remoto` and schedule the Task.

The source decides matching; confirm `modality` in each returned row.

#### Can I extract one job URL?

Yes. Add the supported detail URL to `startUrls` and set `maxItems` to at least one.

#### Are job descriptions included?

Yes. Each item includes plain text in `description` and source HTML in `descriptionHtml`.

#### Does the Actor deduplicate results?

Yes, within a run by country and stable source job ID.

Use `countryCode:jobId` to deduplicate across scheduled runs.

#### Does it scrape applicant profiles?

No. It extracts anonymous public vacancy data only.

### Related Automation Labs actors

For broader job-market workflows, consider these Automation Labs Actors when they match your source:

- [Computrabajo Scraper](https://apify.com/automation-lab/computrabajo-scraper) for another major LATAM job network.
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for LinkedIn vacancy research.
- [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper) for Indeed job listings.

Combine source-specific datasets in a downstream pipeline and retain each source's stable identifier and URL.

# Actor input Schema

## `countryCodes` (type: `array`):

Bumeran-family country sites to search. Results from all selected countries share one normalized dataset.

## `query` (type: `string`):

Optional job keyword or phrase, such as desarrollador, ventas, or remoto. Leave empty to collect the newest vacancies.

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

Optional public job detail URLs from a supported Bumeran-family country site. These are extracted before search results and count toward the same maximum.

## `sort` (type: `string`):

Use recent for monitoring newly published vacancies or relevant for keyword research.

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

Maximum number of fully enriched vacancy records saved across all selected countries and URLs.

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

Concurrent detail requests per country session. Keep the default unless the source becomes unstable.

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

Optional Apify Proxy configuration. Direct public access is used when omitted.

## Actor input object example

```json
{
  "countryCodes": [
    "AR",
    "MX"
  ],
  "query": "desarrollador",
  "startUrls": [],
  "sort": "recent",
  "maxItems": 20,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset view containing enriched job vacancy records.

# 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 = {
    "countryCodes": [
        "AR",
        "MX"
    ],
    "query": "desarrollador",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bumeran-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 = {
    "countryCodes": [
        "AR",
        "MX",
    ],
    "query": "desarrollador",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bumeran-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "countryCodes": [
    "AR",
    "MX"
  ],
  "query": "desarrollador",
  "maxItems": 20
}' |
apify call automation-lab/bumeran-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/n8hkpDZg5Lm1v5s3w/builds/LWvongN2VH3ZbK8U6/openapi.json