# SEPE Empléate Scraper — Spain Job Listings Data (`studio-amba/sepe-scraper`) Actor

Scrape job listings, employers, locations, and posting dates from SEPE's Empléate portal, Spain's state employment service job board. Fast public Solr API access, no login.

- **URL**: https://apify.com/studio-amba/sepe-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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

## SEPE Empléate Scraper

Extract **job listings from [SEPE's Empléate portal](https://www.empleate.gob.es/empleo/)**, the job board run by Spain's Servicio Público de Empleo Estatal (state employment service). Empléate aggregates postings from SEPE's own regional offices plus over a dozen partner boards (engineering, tech, disability employment, and more), making it one of the largest single pools of Spanish vacancies.

This Actor pulls **job titles, employers, locations, posting dates, contract types, and salary ranges** directly from the public Solr search API that powers the Empléate site. No login, no cookies, no browser automation. It reads structured data straight from the source, so runs are fast and stable.

### What does SEPE Empléate Scraper do?

Give it a Spanish keyword (for example `comercial`, `administrativo`, or `programador`) and, optionally, a province. The Actor queries Empléate's Solr search index, paginates through the results, and returns clean, structured records you can download as JSON, CSV, Excel, or HTML — or pull through the Apify API into your own systems.

Because it runs on the Apify platform, you also get scheduling, monitoring, proxy rotation, and integrations (webhooks, Make, Zapier, Google Sheets) out of the box.

### Why use SEPE Empléate Scraper?

- **State-run aggregator.** Empléate pulls together postings from SEPE's regional employment offices and more than a dozen partner boards (COGITI, Tecnoempleo, Hacesfalta, and others) into one index.
- **Nationwide coverage.** Every Spanish province and autonomous community is represented.
- **Labour-market research.** Track hiring demand by occupation, region, or sector over time.
- **Recruitment and sourcing.** Build lead lists of companies actively hiring for a role.
- **Job aggregators.** Feed a niche job site or newsletter with fresh, structured Spanish listings.
- **No anti-bot headaches.** The public API is open, so runs are fast and reliable.

### How to scrape SEPE data

1. Open the Actor and go to the **Input** tab.
2. Enter a **Search Query** in Spanish (e.g., `comercial`, `administrativo`, `camarero`, `programador`).
3. Optionally set a **Location (Province)**, e.g. `MADRID`, `BARCELONA`, or `VALENCIA`.
4. Set **Max Results** to control how many listings you want.
5. Click **Start**. When the run finishes, open the **Output** tab and download your data as JSON, CSV, Excel, or HTML.

That's it. You can also schedule the Actor to run daily and be notified of new listings.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | string | Spanish keyword to search for. Defaults to `comercial`. |
| `location` | string | Spanish province name, e.g. `MADRID`, `BARCELONA`. Leave empty to search all of Spain. |
| `maxResults` | integer | Maximum number of listings to return (default 100). |
| `proxyConfiguration` | object | Proxy settings. The Empléate API is public and open, so Apify datacenter proxies work well. |

#### Example input

```json
{
  "searchQuery": "administrativo",
  "location": "MADRID",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output

Each job is returned as one dataset record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output item

```json
{
  "id": "1854513079",
  "title": "COMERCIAL",
  "company": "MAQUINARIA BOLDOBA SL",
  "locationRaw": "Villariezo, BURGOS, CASTILLA LEON",
  "locationParsed": {
    "city": "Villariezo",
    "country": "Spain"
  },
  "language": "es",
  "postedAt": "2026-05-29T18:41:07Z",
  "descriptionSnippet": "Se ofrece puesto de trabajo como comercial en empresa de venta de maquinaria de obra pública, venta de repuesto, alquiler y reparación. Funciones: CAPTAR CLIENTES VISITAR Y HACER SEGUIMIENTO A LOS CLIENTES...",
  "url": "https://www.empleate.gob.es/empleo/#/oferta/1854513079",
  "employmentType": "Contract — COMPLETA",
  "salaryRaw": "24000 - 25000 EUR/año",
  "source": "sepe.es",
  "scrapedAt": "2026-08-04T18:00:00.000Z"
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `id` | Stable Empléate offer ID (used for de-duplication) |
| `title` | Job posting title |
| `company` | Employer name. Falls back to `"Empresa no especificada"` when the source withholds it (see Limitations) |
| `locationRaw` | Location as SEPE lists it: city, province, autonomous community |
| `locationParsed.city` / `.country` | Structured location |
| `language` | Detected language of the posting (`es`, `ca`, `eu`, or `gl`) |
| `postedAt` | ISO 8601 date the job was published |
| `descriptionSnippet` | Plain-text description, HTML stripped, truncated to ~350 characters |
| `url` | Link to the posting on Empléate |
| `employmentType` | Contract type and working day, when disclosed |
| `salaryRaw` | Salary range, when the employer chose to disclose it |
| `source` | Always `sepe.es` |
| `scrapedAt` | ISO 8601 collection timestamp |

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

The Actor reads a lightweight JSON API, so runs are cheap and fast. A typical run of a few hundred listings finishes in well under a minute and uses a tiny amount of compute. This Actor is billed **pay per result** — you're charged a small fixed cost per result (job posting) plus a per-run start fee, not for compute time. Check the pricing box on the Actor page for the current cost estimate per result. Larger runs simply scale linearly with the number of results.

**Note:** usage cost only settles once a run reports **SUCCEEDED**. If you read the dataset mid-run or after an ABORTED/FAILED run, the item count (and cost) you see is a partial snapshot, not the final total — wait for the run status to flip to SUCCEEDED before reconciling usage.

### Tips and advanced options

- **Narrow with province.** Combine `searchQuery` and `location` to focus on a specific region.
- **Spanish keywords.** The board is Spanish. Use Spanish job titles for the best coverage (e.g. `camarero` not `waiter`).
- **Deduplication.** Results are de-duplicated by offer ID within a run.
- **Broad queries return the most volume.** Common terms like `comercial` or `administrativo` reliably return thousands of matching postings across Spain.

### Limitations

- **Employer name isn't always disclosed.** SEPE's own regional-office postings and a couple of aggregated partner boards (together roughly 60% of all active listings platform-wide) withhold the employer for privacy reasons, same as many state employment services. The Actor returns `"Empresa no especificada"` for these rather than an empty field, and the rest of the record (title, location, dates, contract type) is still fully populated.
- **Salary is only present when the employer chose to disclose it.** Most listings omit it.
- **No direct external URL for most postings.** The link returned is the canonical Empléate detail page, not the original employer posting.

### FAQ, disclaimers, and support

**Is scraping SEPE Empléate legal?** This Actor reads a public API that the Spanish state employment service exposes for its own web app. Use the data responsibly and in line with applicable terms and data-protection law. You are responsible for how you use the extracted data.

**Do I need an account or API key?** No. The Actor handles API access for you. No login or cookies are required.

**Why is the company field sometimes "Empresa no especificada"?** See Limitations above — a large share of postings, especially those sourced directly from SEPE's public employment offices, don't disclose the employer name in the source data.

**Something's not working.** Open an issue on the Actor's **Issues** tab with your input and the run link. Custom fields or a tailored version can also be arranged.

### Related Scrapers

Looking for job data from other European public employment services? Studio AMBA also maintains:

- [France Travail Scraper](https://apify.com/studio-amba/francetravail-scraper) — France's state employment service
- [VDAB Scraper](https://apify.com/studio-amba/vdab-scraper) — Flanders (Belgium) employment service
- [Le Forem Scraper](https://apify.com/studio-amba/leforem-scraper) — Wallonia (Belgium) employment service
- [Werk.nl Scraper](https://apify.com/studio-amba/werk-nl-scraper) — Netherlands employment service (UWV)
- [Arbeitsagentur Scraper](https://apify.com/studio-amba/arbeitsagentur-scraper) — Germany's Federal Employment Agency
- [Arbetsförmedlingen Scraper](https://apify.com/studio-amba/arbetsformedlingen-scraper) — Sweden's Public Employment Service

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for (Spanish). Examples: 'comercial' (sales), 'administrativo' (office admin), 'programador' (developer), 'camarero' (waiter). Leave empty to use the default.

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

Filter by Spanish province name, e.g. 'MADRID', 'BARCELONA', 'VALENCIA', 'SEVILLA'. Uses the province name as SEPE lists it (uppercase, no accents needed). Leave empty to search all of Spain.

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

Maximum number of job listings to return.

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

Proxy settings. The Empléate Solr API is public and open, so Apify datacenter proxies work well.

## Actor input object example

```json
{
  "searchQuery": "comercial",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQuery": "comercial",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/sepe-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 = {
    "searchQuery": "comercial",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/sepe-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 '{
  "searchQuery": "comercial",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/sepe-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/sepe-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/6zSfRNbmZyL02nRFs/builds/HljAyJvtBjBol3EKI/openapi.json