# GetOnBrd Jobs Scraper — Tech Jobs in Latin America (`fabrikit/getonbrd-jobs-scraper`) Actor

Scrape tech jobs in Latin America from GetOnBrd: title, company, salary range in USD, seniority, remote/hybrid/on-site, tech stack tags. US$0.50 per 1,000 jobs.

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

## Pricing

from $0.50 / 1,000 job results

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/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

## GetOnBrd Jobs Scraper — Tech Jobs in Latin America

Scrape **tech job postings from GetOnBrd**, the largest tech job board in Latin America, into a clean, normalized dataset — the fastest way to get LATAM tech jobs data with salary ranges in USD. Pick a category, a search term, a country or just "remote only", and get back every job with title, company, **salary range in USD**, seniority, remote/hybrid/on-site mode, tech-stack tags and publication date. Export to CSV, Excel, JSON or Google Sheets.

What you get from a single run:

- **Salary transparency you won't find elsewhere**: GetOnBrd requires many postings to publish a salary range — this Actor returns `salaryMin`/`salaryMax` in USD, ready for compensation benchmarks.
- **Real filters that work together**: category (Programming, Data Science, Design/UX...), free-text search, seniority, country (`CL`, `MX`, `AR`, `CO`, `PE`...) and remote-only — filters the site's own API can't combine are applied for you.
- **The tech stack of every job** as clean tags (`Python`, `React`, `AWS`...), plus perks, applicant counts and a direct application URL.

Example output item (real job, August 2026):

```json
{
    "id": "senior-software-engineer-java-angular-english-23people-santiago-e811",
    "title": "Senior Software Developer Java/Spring Boot (English)",
    "company": "23people",
    "companyLogo": "https://getonbrd-prod.s3.amazonaws.com/uploads/users/logo/4457/Foto_perfil_Tiktok.png",
    "category": "Programming",
    "seniority": "Senior",
    "contractType": "Full time",
    "workMode": "remote",
    "remote": true,
    "remoteModality": "remote_local",
    "countries": ["Remote"],
    "salaryMin": 2900,
    "salaryMax": 3200,
    "salaryCurrency": "USD",
    "publishedAt": "2026-08-21T01:43:41.000Z",
    "applicationsCount": 297,
    "tags": ["Java", "Spring Boot", "PostgreSQL", "AWS", "Cloud Computing"],
    "perks": ["flexible_hours", "health_coverage", "computer_provided"],
    "url": "https://www.getonbrd.com/jobs/senior-software-engineer-java-angular-english-23people-santiago-e811",
    "description": null,
    "scrapedAt": "2026-08-21T01:59:14.049Z"
}
```

### How to scrape GetOnBrd jobs

1. Pick a **category** (Programming, Machine Learning & AI, Data Science, DevOps, Mobile, Design/UX...) or leave "All categories".
2. Optionally add a **search term** (`python`, `react`, `data engineer`), a **country** code (`CL`, `MX`, `AR`...), a **seniority** level, or switch on **remote only**.
3. Press **Start**. Jobs land in the dataset within seconds, ready to download as CSV, Excel or JSON, or to sync to Google Sheets, webhooks, Zapier or Make.

#### Example input

```json
{
    "category": "programming",
    "maxJobs": 50
}
```

- **category** — one of GetOnBrd's 18 categories, or `all`.
- **searchTerm** — free-text search across all postings. Combined with `category`, results are filtered to that category.
- **remoteOnly** — only jobs that can be done remotely (fully remote or remote within a region).
- **country** — two-letter code (`CL`, `MX`, `AR`, `CO`, `PE`, `BR`...) for jobs located in or hirable from that country.
- **seniority** — `no_experience`, `junior`, `semi_senior`, `senior` or `expert`.
- **maxJobs** — stop after this many jobs (after filters). `0` = no limit.
- **includeDescription** — add the full job description as plain text (HTML stripped). Off by default to keep items small.

#### Example: remote senior Python jobs, full description

```json
{
    "searchTerm": "python",
    "remoteOnly": true,
    "seniority": "senior",
    "includeDescription": true,
    "maxJobs": 100
}
```

#### Example: all Design/UX jobs in Chile

```json
{
    "category": "design-ux",
    "country": "CL",
    "maxJobs": 200
}
```

### GetOnBrd API — jobs data without writing integration code

GetOnBrd exposes a public JSON API, but using it raw means dealing with JSON:API envelopes, numeric relationship IDs that need a second lookup, a page-size cap, and filters that reject each other (the API refuses `country` + `remote` in the same request, and category endpoints ignore filter parameters entirely). This Actor handles all of that: it expands companies, seniorities and tags inline, applies every filter combination client-side when the API can't, paginates for you and outputs flat, analysis-ready rows. No token, no login, no browser, no proxies.

### LATAM tech jobs data for salary benchmarks and market research

Latin America's tech job market is hard to see from the outside — LinkedIn data is noisy and salaries are hidden. GetOnBrd is where Chilean, Mexican, Colombian and Argentine tech companies actually hire, and a large share of postings include **public salary ranges in USD**. That makes this dataset ideal for:

- **Salary benchmarking:** average `salaryMin`/`salaryMax` by seniority, tag or country.
- **Recruiting and sourcing:** feed fresh postings into your ATS or outreach pipeline; `applicationsCount` shows where competition is low.
- **Tech-stack trends:** count `tags` over time — which frameworks LATAM companies are hiring for right now.
- **Job boards and aggregators:** a normalized LATAM feed with direct application URLs.
- **Remote-work research:** `workMode` splits every job into `remote`, `hybrid` or `on-site`.

### Output fields

| Field | Type | Description |
|---|---|---|
| `id` | string | GetOnBrd's unique job slug |
| `title` | string | Job title |
| `company` | string | null | Company name |
| `companyLogo` | string | null | Company logo URL |
| `category` | string | null | Category display name (e.g. `Programming`) |
| `seniority` | string | null | `No experience`, `Junior`, `Semi Senior`, `Senior`, `Expert` |
| `contractType` | string | null | `Full time`, `Part time`, `Freelance`, `Práctica/Internship` |
| `workMode` | string | `remote`, `hybrid` or `on-site` |
| `remote` | boolean | Can the job be done remotely |
| `remoteModality` | string | null | Raw API value (`fully_remote`, `remote_local`, `hybrid`...) |
| `countries` | array | Countries the job is located in / hirable from |
| `salaryMin` | number | null | Lower bound of the published salary range |
| `salaryMax` | number | null | Upper bound of the published salary range |
| `salaryCurrency` | string | null | `USD` when a salary is published |
| `publishedAt` | string | null | ISO 8601 publication date |
| `applicationsCount` | number | null | Number of applications so far |
| `tags` | array | Tech stack / skills (`Python`, `React`, `AWS`...) |
| `perks` | array | Perks (`flexible_hours`, `health_coverage`...) |
| `url` | string | Direct link to the job posting |
| `description` | string | null | Plain-text description (only with `includeDescription`) |
| `scrapedAt` | string | ISO 8601 timestamp of this run |

A run summary (jobs per source, items filtered out, errors) is stored in the run's key-value store under `SUMMARY`.

### Integrations — call this Actor from Python or JavaScript

Run the Actor and fetch its results from your own code via the Apify API:

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("fabrikit/getonbrd-jobs-scraper").call(run_input={
    "category": "programming",
    "remoteOnly": True,
    "seniority": "senior",
    "maxJobs": 200,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["company"], job["salaryMin"], job["salaryMax"])
```

**JavaScript** (`npm install apify-client`):

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

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

const run = await client.actor('fabrikit/getonbrd-jobs-scraper').call({
    searchTerm: 'react',
    country: 'MX',
    maxJobs: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} jobs`, items[0]);
```

Every Apify dataset also exports to **CSV, Excel, JSON, XML or HTML** with one click, or syncs to **Google Sheets, webhooks, Zapier, Make and LangChain** through Apify's built-in integrations. Schedule the Actor daily or weekly in Apify Console for a rolling LATAM jobs feed with zero code.

### Performance & limits

- Plain HTTP against GetOnBrd's public JSON API — **no browser, no proxies**, so runs are fast and cheap: 50 jobs in a few seconds, hundreds in well under a minute.
- Pagination is handled automatically (the API caps pages at 120 items; the Actor requests 100 per page).
- The board typically lists **1,500–3,000 active jobs** across all categories; `maxJobs: 0` scrapes everything.
- Seniority, remote-only-with-country and category-plus-search filters are applied client-side (the upstream API cannot combine them), so highly restrictive combinations read more pages than they return jobs. That is normal — you are only charged for jobs actually delivered.
- Items are unique per job `id` within a run.

### Tips for best results

- **For everything in one category**, use `category` alone — it is the fastest path (server-side, no filtering overhead).
- **For salary analytics**, filter the dataset where `salaryCurrency = "USD"` — roughly 40–50% of postings publish a range.
- **Descriptions are off by default**; switch on `includeDescription` only when you need the text (sentiment, LLM matching, keyword mining) — items get ~10× bigger with it.
- **For fresh-jobs monitoring**, schedule a daily run with `maxJobs: 100` sorted output — postings come back newest first — and dedupe on `id` downstream.
- **Country codes** follow ISO 3166-1 alpha-2 (`CL` Chile, `MX` Mexico, `AR` Argentina, `CO` Colombia, `PE` Peru, `BR` Brazil...).

### Pricing — US$0.50 per 1,000 jobs

This Actor uses Apify's **pay-per-event** model and charges **per job delivered** (event `job-result`, **US$0.0005 per job = US$0.50 per 1,000 jobs**) on top of standard Apify platform usage. No subscription, no rental fee, no proxy costs. Scraping the whole board (~2,500 jobs) costs about US$1.25 in events. You only pay for jobs actually pushed to your dataset.

### FAQ

**What is GetOnBrd?**
The leading tech job board in Latin America (getonbrd.com), used by thousands of companies in Chile, Mexico, Colombia, Argentina and Peru — and one of the few boards where salary ranges are frequently public.

**Do I need a GetOnBrd API token?**
No. The Actor reads GetOnBrd's public JSON API, which serves job data without authentication.

**Are salaries really in USD?**
Yes — GetOnBrd publishes salary ranges in USD (monthly), which is the board's convention across all countries.

**Why do some jobs have no salary?**
Not every posting publishes a range. Fields are `null` when the company didn't disclose it; typically 40–50% of jobs include one.

**Can I filter remote jobs in a specific country?**
Yes — set both `remoteOnly: true` and `country`. The upstream API rejects that combination, so the Actor fetches by country and applies the remote filter itself.

**How fresh is the data?**
Live — every run hits GetOnBrd's API directly. Jobs are returned newest first; schedule the Actor to build a rolling feed.

**Is it legal to scrape GetOnBrd?**
The Actor only reads data GetOnBrd itself publishes through its public, unauthenticated API — the same data shown on the public site. How you use it is up to your own compliance requirements.

**Can I export to CSV or Excel?**
Yes — one click in Apify Console, or automatically via the Google Sheets integration, webhooks, Zapier, Make or the Apify API.

**What categories exist?**
Programming, Machine Learning & AI, Data Science / Analytics, SysAdmin / DevOps / QA, Mobile Developer, Design / UX, Cybersecurity, Digital Marketing, Advertising & Media, Sales, Operations / Management, Innovation & Agile, Customer Support, Technical Support, People & HR, Education & Coaching, Hardware / Electronics, Other.

### Support

Issues and questions are **responded to in under 24 hours** — open an issue on the Actor's Issues tab and it will be handled quickly.

### More scrapers by Fabrikit

- **[ATS Jobs Scraper — Greenhouse, Lever, Ashby & SmartRecruiters](https://apify.com/fabrikit/ats-jobs-api)** — job postings from any company on the four biggest ATS platforms in one normalized feed, with ATS auto-detection and a built-in remote filter.
- **[App Reviews Scraper — App Store & Google Play](https://apify.com/fabrikit/app-reviews-unified)** — reviews from both mobile stores in one run and one schema: rating, text, version, helpful votes and developer replies.
- **[Portal Inmobiliario Scraper — Chile Real Estate](https://apify.com/fabrikit/portal-inmobiliario-scraper)** — Chilean real estate listings with prices in CLP/UF, size, bedrooms and location with lat/lon.

### Technical details

- Data source: GetOnBrd's public JSON API (`getonbrd.com/api/v0`) — category endpoints plus the cross-category search endpoint, chosen automatically per input.
- Related records (company, seniority, contract type, tags) are expanded inline in a single request per page — no N+1 lookups.
- Filters the upstream API can't combine (remote + country, category + search, seniority anywhere) are applied client-side.
- Items are unique per job `id` within a run; malformed jobs are skipped and counted in `SUMMARY`, never abort the run.
- A run summary is stored in the key-value store under `SUMMARY`.

# Actor input Schema

## `category` (type: `string`):

Job category on GetOnBrd. Leave on "All categories" to scrape everything (or combine with a search term / country).

## `searchTerm` (type: `string`):

Free-text search across all job postings (e.g. `python`, `react`, `data engineer`). Searches every category; if you also pick a category, results are filtered to it.

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

Only keep jobs that can be done remotely (fully remote or remote within a region).

## `country` (type: `string`):

Two-letter country code to only get jobs located in (or hirable from) that country: `CL`, `MX`, `AR`, `CO`, `PE`, `BR`... Leave empty for all countries.

## `seniority` (type: `string`):

Only keep jobs of this seniority level.

## `maxJobs` (type: `integer`):

Stop after this many jobs (after filters). 0 = no limit.

## `includeDescription` (type: `boolean`):

Add the full job description (requirements + role functions, HTML stripped to plain text) to every item. Off by default to keep items small.

## Actor input object example

```json
{
  "category": "programming",
  "remoteOnly": false,
  "seniority": "any",
  "maxJobs": 50,
  "includeDescription": false
}
```

# Actor output Schema

## `jobs` (type: `string`):

All normalized job postings collected during the run

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/getonbrd-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/getonbrd-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 '{}' |
apify call fabrikit/getonbrd-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/getonbrd-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/f9bJesdW6v3bfaINX/builds/9ysf7ia4FFcQpe7gX/openapi.json