# Jobrapido Scraper - Global Job Data (`benthepythondev/jobrapido-scraper`) Actor

Scrape Jobrapido job search results: title, company, location, posted date, description and job URL across multiple country sites.

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

## Pricing

from $3.00 / 1,000 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Jobrapido Scraper - Global Job Search Data

Scrape job listings from **Jobrapido** search pages in one run. Get structured job data including title, company, location, posted date, short description, source and job URL. Export the results to JSON, CSV, Excel, Google Sheets, Make, Zapier, n8n or your own API pipeline.

### What is the Jobrapido Scraper?

Jobrapido is a job-search aggregator that indexes vacancies across many countries and industries. Recruiters, analysts and job-market teams use it to monitor hiring demand, compare employer activity, track roles by keyword, collect job leads and build market snapshots.

This actor turns Jobrapido search results into a clean dataset. You can paste exact Jobrapido search URLs or let the actor build a search from a keyword, location and country site. The scraper uses a lightweight HTTP engine and parses server-rendered result cards, so it does not need a browser, login, cookie export or paid unblocker for normal searches.

### Why use this actor?

Use this scraper when you need reliable job data without manually browsing result pages. It is useful for:

- lead generation for recruiting agencies and staffing companies
- competitive hiring intelligence by role, city or country
- job-market research for salary, demand and location trends
- sourcing target employers that are actively hiring
- monitoring tech, sales, finance, healthcare or operations job demand
- feeding internal dashboards, CRMs or outbound workflows

The output is intentionally flat and automation-friendly. Each row is one job listing, with stable field names suitable for spreadsheets, databases and API integrations.

### Input

You can run the actor in two ways.

Paste one or more Jobrapido search URLs:

```json
{
  "searchUrls": [
    "https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"
  ],
  "maxResults": 25
}
````

Or let the actor build a search URL:

```json
{
  "keyword": "python",
  "location": "New York, NY",
  "country": "us",
  "maxResults": 25
}
```

Supported country shortcuts include `us`, `uk`, `de`, `fr`, `it`, `es`, `ca` and `au`. For more specific filters, paste the full Jobrapido URL after applying filters on the website.

### Output

Each dataset item contains fields like:

```json
{
  "job_id": "example-job-id",
  "title": "Python Developer",
  "company": "Example Company",
  "location": "New York, NY",
  "posted": "2 days ago",
  "description": "Short job summary from the result card",
  "url": "https://us.jobrapido.com/jobpreview/...",
  "source": "Jobrapido",
  "search": "https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"
}
```

Fields may vary depending on what Jobrapido shows for a specific country or listing. If a field is not present on the result card, it is returned as `null` rather than guessed.

### Pricing

This actor uses pay-per-event pricing:

- small actor start fee per run
- one `result` event for each job pushed to the dataset

That keeps small tests inexpensive while allowing larger exports when you need them.

### Tips for best results

Use exact search URLs for repeatable runs. If you care about a specific country, distance radius, keyword spelling or city, configure it on Jobrapido first and paste the resulting URL into `searchUrls`.

Keep scheduled runs focused. Instead of one huge generic search, create several targeted saved tasks such as `python Berlin`, `sales London`, `nurse Toronto` or `devops New York`. Targeted runs produce cleaner lead lists and are easier to compare over time.

Set `maxResults` low while testing. Once the output matches what you need, increase it for production runs or schedules.

For recruiting lead generation, pair this actor with a contact enrichment step. Jobrapido often exposes the hiring company and source website on the result card. You can export the company names, enrich them with a domain/contact actor, then route the leads into a CRM or outbound sequence. This keeps the Jobrapido run fast while still supporting a complete prospecting workflow.

For market intelligence, schedule the same search weekly or daily and compare the output over time. Because the actor returns stable fields such as title, company, location and source website, it is straightforward to track which employers keep hiring, which cities are active, and which keywords are growing across countries. This is especially useful for staffing agencies, salary research, workforce planning and competitive intelligence teams.

For international research, create one saved task per country site instead of mixing many countries into one run. Separate tasks make it easier to compare US, UK, German, French, Italian, Spanish, Canadian and Australian markets without cleaning a large mixed dataset afterward.

### Integrations

You can export the dataset manually or connect it to:

- Google Sheets for recruiting research
- Airtable or Notion for job lead lists
- HubSpot, Pipedrive or Salesforce for employer prospecting
- Make, Zapier or n8n for automated workflows
- BI tools for hiring-market dashboards
- your backend via the Apify API

### FAQ

#### Does this scraper require a Jobrapido account?

No. It reads public Jobrapido search-result pages.

#### Does it scrape full job descriptions?

This actor focuses on search-result data. It returns the title, company, location, snippet and URL shown on the result card. Full detail-page scraping can be added as a separate workflow if needed, but result-card scraping is faster and more reliable for scheduled monitoring.

#### Can I scrape multiple countries?

Yes. Paste URLs from different Jobrapido country sites or run separate tasks with different country values.

#### Is it safe for daily auto-tests and schedules?

The actor is designed for lightweight HTTP scraping. It avoids browser automation and keeps the default run small, which makes it suitable for scheduled runs and store auto-tests.

#### Why are some fields empty?

Jobrapido cards vary by country and source. The scraper returns only fields available in the result card and avoids inventing data.

### You might also like

- StepStone Scraper
- Reed Jobs Scraper
- Totaljobs Scraper
- CWJobs Scraper
- JustJoin.it Scraper
- iCIMS Jobs Scraper
- Workable Jobs Scraper
- SmartRecruiters Jobs Scraper
- Website Contact Extractor
- Google Maps Email Scraper

### Keywords

Jobrapido scraper, Jobrapido jobs API, job search scraper, global job scraper, recruiting leads, hiring intelligence, job board scraper, job listings export, employment data, staffing lead generation, job market research, Apify jobs scraper.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste Jobrapido search-result URLs. If empty, the actor builds a search from keyword, location and country.

## `keyword` (type: `string`):

Job title, skill or search term used when Search URLs is empty.

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

Location used when Search URLs is empty.

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

Jobrapido country site to search when building a URL.

## `maxResults` (type: `integer`):

Maximum number of jobs to return per URL.

## Actor input object example

```json
{
  "searchUrls": [
    "https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"
  ],
  "keyword": "python",
  "location": "New York, NY",
  "country": "us",
  "maxResults": 10
}
```

# 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 = {
    "searchUrls": [
        "https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"
    ],
    "keyword": "python",
    "location": "New York, NY",
    "country": "us",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/jobrapido-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 = {
    "searchUrls": ["https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"],
    "keyword": "python",
    "location": "New York, NY",
    "country": "us",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/jobrapido-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 '{
  "searchUrls": [
    "https://us.jobrapido.com/?w=python&l=New%20York%2C%20NY"
  ],
  "keyword": "python",
  "location": "New York, NY",
  "country": "us",
  "maxResults": 10
}' |
apify call benthepythondev/jobrapido-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobrapido Scraper - Global Job Data",
        "description": "Scrape Jobrapido job search results: title, company, location, posted date, description and job URL across multiple country sites.",
        "version": "1.0",
        "x-build-id": "7oEywqcxxysYgTnn4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~jobrapido-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-jobrapido-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~jobrapido-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-jobrapido-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~jobrapido-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-jobrapido-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste Jobrapido search-result URLs. If empty, the actor builds a search from keyword, location and country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job title, skill or search term used when Search URLs is empty.",
                        "default": "python"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location used when Search URLs is empty.",
                        "default": "New York, NY"
                    },
                    "country": {
                        "title": "Country site",
                        "enum": [
                            "us",
                            "uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ca",
                            "au"
                        ],
                        "type": "string",
                        "description": "Jobrapido country site to search when building a URL.",
                        "default": "us"
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return per URL.",
                        "default": 40
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
