# InfoJobs Scraper (Cheap) (`data_api/infojobs-scraper-cheap`) Actor

Pulls job listings from InfoJobs.net by keyword, location, and category, so you can track Spanish salary ranges and hiring trends without manual browsing.

- **URL**: https://apify.com/data\_api/infojobs-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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.
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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## InfoJobs Job Scraper

Watching the Spanish job market on infojobs.net usually means opening posting after posting and copying out the title, company, salary, and contract by hand. This scraper does the collecting for you. Type in the roles you're after, pick the cities or provinces (or skip that to cover all of Spain), and every match comes back as a tidy row — position, employer, pay range, schedule, and the full description already split into fields. It's fast, cheap, and code-free, and you pay only for what you scrape.

![InfoJobs Job Scraper](cover.jpg)

### What you get

Each posting is returned as a single row, grouped into three kinds of data:

- **Role and employer** — `positionTitle`, `employerName`, `cityName`, `contractKind`, `scheduleType`, `remoteMode`, `isRemote`, `isUrgent`
- **Pay** — `payRange`, `payMin`, `payMax`
- **Detail and tracking** — `roleSummary`, `publishedAt`, `listingUrl`, `offerId`, `collectedAt`, `errorMessage`

### Quick start

1. Type one or more roles into **Job search terms** (for example `desarrollador java`).
2. Add the **Cities or provinces** you want, or leave it empty to search all of Spain.
3. Optionally set a **Category filter** or **Contract filter** to tighten the matches.
4. Set a **Results per search** limit, press **Start**, then export as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Job seekers** — line up openings for your role across several cities in one sweep
- **Recruiters and sourcers** — track which companies are hiring, where, and at what pay
- **Salary benchmarking** — gather `payMin` and `payMax` across a role to see the going rate
- **Market research** — measure hiring demand by category, contract type, or province
- **Lead generation** — build a list of employers actively posting for the skills you sell

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | Roles or skills to look up; each term is searched separately and the matches are merged. Prefilled with `desarrollador java`. |
| `searchAreas` | array of strings | No | Spanish cities or provinces to search. Leave empty to cover the whole country. Each area pairs with every term. |
| `jobCategory` | string | No | Narrow results to one InfoJobs sector. Default all categories. |
| `contractKind` | string | No | Keep only a given contract type (permanent, temporary, internship, freelance). Default any. |
| `withFullDescription` | boolean | No | Bring back the complete posting text. Turn off for metadata only. Default `true`. |
| `resultsLimit` | integer | No | How many postings to gather per term and area pairing. Default `25`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `45`. |

#### Example input

```json
{
    "searchTerms": ["desarrollador java", "product manager"],
    "searchAreas": ["Sevilla", "Bilbao"],
    "jobCategory": "informatica-telecomunicaciones",
    "contractKind": "indefinido",
    "withFullDescription": true,
    "resultsLimit": 25,
    "timeoutSeconds": 45
}
````

### Output

Every posting on the search results becomes one row, paginated automatically up to your limit. Fields InfoJobs does not publish for a given role come back as null rather than guessed, and duplicate offers across overlapping searches are removed.

#### Example output

```json
{
    "positionTitle": "Desarrollador Java Senior",
    "employerName": "Innova Digital SL",
    "cityName": "Sevilla",
    "payRange": "28.000 - 40.000 EUR Bruto/año",
    "payMin": 28000,
    "payMax": 40000,
    "contractKind": "Contrato indefinido",
    "scheduleType": "Jornada completa",
    "remoteMode": "Híbrido",
    "roleSummary": "Buscamos un Desarrollador Java con experiencia en Spring Boot y microservicios para unirse a nuestro equipo de producto.",
    "publishedAt": "2026-05-22T08:57:00Z",
    "listingUrl": "https://www.infojobs.net/sevilla/desarrollador-java/of-i1d188ed1",
    "offerId": "1d188ed1ab43e68a3dff7af0a82da2",
    "isRemote": true,
    "isUrgent": false,
    "collectedAt": "2026-05-23T11:30:00+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `positionTitle` | string | Title of the advertised role |
| `employerName` | string | Company that posted the opening |
| `cityName` | string | Town or city the role is based in |
| `payRange` | string | Salary range as a ready-to-read string |
| `payMin` | integer | Lower bound of the yearly salary in euros |
| `payMax` | integer | Upper bound of the yearly salary in euros |
| `contractKind` | string | Employment contract on offer |
| `scheduleType` | string | Working hours arrangement, e.g. Jornada completa |
| `remoteMode` | string | Solo teletrabajo, Híbrido, or Presencial |
| `roleSummary` | string | Full description text from the posting |
| `publishedAt` | string | ISO 8601 timestamp when the role went live |
| `listingUrl` | string | Direct link to the posting on InfoJobs |
| `offerId` | string | InfoJobs internal offer code |
| `isRemote` | boolean | True when the role is Híbrido or Solo teletrabajo |
| `isUrgent` | boolean | Flags postings the employer tagged as urgent |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason a fetch failed; null on a clean row |

### Tips for best results

- **Match locations to real Spanish places.** `searchAreas` maps city and province names to InfoJobs regions, so spelling like `Sevilla` or `Bilbao` works; leave it blank to search the whole country.
- **Use `resultsLimit` for test runs.** Start at 25 to confirm the output fits your pipeline, then raise it for a fuller pull.
- **Combine terms and areas freely.** Each term runs against each area, so three roles across two cities is six searches in one go.
- **Turn off `withFullDescription`** when you only need metadata — the export gets lighter and faster.
- **Raise `timeoutSeconds`** if you hit timeouts on busy searches with many pages.

### How can I use InfoJobs job data?

**How can I use the InfoJobs Job Scraper to find openings across several cities?**
Add the roles you want under `searchTerms`, list the cities under `searchAreas`, and run it. Each term is matched against each area, and you get back `positionTitle`, `employerName`, `cityName`, and `listingUrl` for every result in one combined dataset.

**How can I benchmark salaries from InfoJobs postings?**
Search a single role across the regions you care about and read `payMin`, `payMax`, and `payRange` per row. Export to CSV or Excel and you have a salary spread for that role you can chart or compare against your own offers.

**How can I track which companies are hiring on InfoJobs?**
Set a `jobCategory` or `contractKind`, run on a schedule, and watch `employerName`, `publishedAt`, and `contractKind` over time. That gives you a live read on hiring demand by sector, plus a list of employers actively posting for the skills you target.

**How can I pull InfoJobs job data into my own spreadsheet or app?**
Run the scraper, then export as JSON, CSV, Excel, or XML, or pull the dataset through the Apify API. Every posting arrives as structured fields (role, employer, pay, schedule, description), so it drops straight into a sheet, BI tool, or database.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchTerms` (type: `array`):

The roles or skills you want to look up. Add as many as you like — each term is searched on its own and the matches are merged into one dataset. For example 'desarrollador java', 'product manager', or 'enfermero'.

## `searchAreas` (type: `array`):

Where to look. List the Spanish cities or provinces you care about, or leave it blank to cover the whole country. Every area you add is paired with every search term. For example 'Sevilla', 'Bilbao', 'Zaragoza'.

## `jobCategory` (type: `string`):

Narrow the matches down to a single InfoJobs job sector.

## `contractKind` (type: `string`):

Keep only postings that offer a given type of employment contract.

## `withFullDescription` (type: `boolean`):

Turn this on to bring back the complete description for every posting. Switch it off for a slimmer, metadata-only export.

## `resultsLimit` (type: `integer`):

How many postings to gather for each search term and area pairing. With 3 terms across 2 areas and a limit of 25, you can collect up to 150 rows in total (25 per pairing).

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up.

## Actor input object example

```json
{
  "searchTerms": [
    "desarrollador java",
    "product manager"
  ],
  "searchAreas": [
    "Sevilla",
    "Bilbao"
  ],
  "jobCategory": "",
  "contractKind": "",
  "withFullDescription": true,
  "resultsLimit": 20,
  "timeoutSeconds": 45
}
```

# 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 = {
    "searchTerms": [
        "desarrollador java"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/infojobs-scraper-cheap").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 = { "searchTerms": ["desarrollador java"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/infojobs-scraper-cheap").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 '{
  "searchTerms": [
    "desarrollador java"
  ]
}' |
apify call data_api/infojobs-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "InfoJobs Scraper (Cheap)",
        "description": "Pulls job listings from InfoJobs.net by keyword, location, and category, so you can track Spanish salary ranges and hiring trends without manual browsing.",
        "version": "0.0",
        "x-build-id": "rdPZVUsZHiptRW2Ya"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~infojobs-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-infojobs-scraper-cheap",
                "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/data_api~infojobs-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-infojobs-scraper-cheap",
                "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/data_api~infojobs-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-infojobs-scraper-cheap",
                "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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Job search terms",
                        "type": "array",
                        "description": "The roles or skills you want to look up. Add as many as you like — each term is searched on its own and the matches are merged into one dataset. For example 'desarrollador java', 'product manager', or 'enfermero'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchAreas": {
                        "title": "Cities or provinces",
                        "type": "array",
                        "description": "Where to look. List the Spanish cities or provinces you care about, or leave it blank to cover the whole country. Every area you add is paired with every search term. For example 'Sevilla', 'Bilbao', 'Zaragoza'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobCategory": {
                        "title": "Category filter",
                        "enum": [
                            "",
                            "informatica-telecomunicaciones",
                            "marketing-publicidad-comunicacion",
                            "administracion-empresas",
                            "comercial-ventas",
                            "recursos-humanos",
                            "contabilidad-finanzas-banca",
                            "ingenieria-produccion-industrial",
                            "atencion-clientes-call-center",
                            "diseno-artes-graficas",
                            "educacion-formacion",
                            "hosteleria-turismo",
                            "legal-asesorias",
                            "logistica-transporte-trafico",
                            "sanidad-salud",
                            "inmobiliario-construccion"
                        ],
                        "type": "string",
                        "description": "Narrow the matches down to a single InfoJobs job sector.",
                        "default": ""
                    },
                    "contractKind": {
                        "title": "Contract filter",
                        "enum": [
                            "",
                            "indefinido",
                            "temporal",
                            "practicas",
                            "autonomo"
                        ],
                        "type": "string",
                        "description": "Keep only postings that offer a given type of employment contract.",
                        "default": ""
                    },
                    "withFullDescription": {
                        "title": "Capture the full posting text",
                        "type": "boolean",
                        "description": "Turn this on to bring back the complete description for every posting. Switch it off for a slimmer, metadata-only export.",
                        "default": true
                    },
                    "resultsLimit": {
                        "title": "Results per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many postings to gather for each search term and area pairing. With 3 terms across 2 areas and a limit of 25, you can collect up to 150 rows in total (25 per pairing).",
                        "default": 20
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
