# Jobs2Careers Scraper (`gauzy_penguin/jobs2careers-scraper`) Actor

Scrapes job listings from Jobs2Careers search results. Supports keyword search, locations, and various filters.

- **URL**: https://apify.com/gauzy\_penguin/jobs2careers-scraper.md
- **Developed by:** [locas mora](https://apify.com/gauzy_penguin) (community)
- **Categories:** Jobs, AI, Automation
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 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 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

## Job Listings jobs2careers Scraper | Fast Multi-Keyword Job Data Extractor

Extract structured job listings at scale from **"https://www.jobs2careers.com/"** using fast, asynchronous scraping with pagination, retries, and concurrency control.

This actor is designed for **job market intelligence, recruitment automation, salary tracking, and workforce analytics**.

---

## Performance Overview:

This run demonstrates the actor’s production-grade efficiency, processing 6,323 job listings in under a minute with low memory usage (~110 MB avg) and stable CPU utilization, confirming strong scalability and I/O-optimized architecture.

![production-grade efficiency](https://api.apify.com/v2/key-value-stores/bfCbIXneBpZEREunx/records/image.png)

## Overview

**The Job Listings jobs2careers Scraper** is a production-grade Apify actor that collects job advertisements based on keywords and locations.

It supports:
- Multi-keyword scraping
- Pagination handling
- Retry + rate-limit management
- Concurrent execution
- Structured job extraction

The scraper is optimized for:
- Job market analysis
- Talent intelligence
- Recruitment automation
- Remote job tracking
- Salary research datasets

---

## Key Features

- ⚡ Async concurrent keyword scraping
- 🔁 Automatic pagination support
- 🛡 Retry mechanism with exponential backoff
- 📦 Batch dataset output (optimized writes)
- 🎯 Multi-keyword input support
- 🌍 Location-based job filtering
- 📊 Scalable for large job datasets
- ⚙️ Apify-native architecture

---

## How It Works

1. Input keywords are parsed (comma-separated list)
2. Each keyword is processed concurrently (controlled with semaphore)
3. The scraper queries job search endpoints using structured parameters
4. Results are paginated automatically
5. Job ads are normalized and stored in Apify dataset
6. Retry logic handles rate limits and server errors

---

## Input Configuration

### Required Fields

| Field | Type | Description |
|------|------|-------------|
| `keywords` | string | Comma-separated list of job search keywords |
| `location` | string | Job location (e.g., "New York, NY") |

---

### Optional Fields

| Field | Type | Description |
|------|------|-------------|
| `maxItems` | integer | Maximum number of job ads to scrape per keyword |
| `benefit` | string | Filter by job benefits |
| `workType` | string | Full-time / Part-time / Contract |
| `date` | string | Date filter (e.g., last 24h, last 7d) |
| `salary_period` | string | Salary time unit |
| `commute` | integer | Commute distance filter |

---

## Example Input

```json
{
  "keywords": "data engineer, data scientist, backend developer",
  "location": "New York, NY",
  "maxItems": 500,
  "workType": "full-time"
}
````

***

## Output Data Structure

Each job listing is stored as a structured JSON object:

```json
{
  "id": "35892049874",
  "title": "Field Structural Engineer (Solar Focused)",
  "companyName": "Pure Power Engineering",
  "location": "Hoboken, NJ",
  "datePosted": "2026-05-22T16:01:39Z",
  "url": "https://www.jobs2careers.com/click.php?jid=8d6832031b0d71e28f5afe9e7&ri=a1db1e549b954c1fa3ef3b05637f2a27&job_loc=Hoboken%2CNJ&q=Software+Engineer&spl=v1%253AV9wSHugKYWd9KGZD%253A8TXGhxAQtDPG9fqH5TYPJw%253D%253D%253A18dS4pTsadmGGlLVb5OLOficnbhE7zcyMSOdLATNAYQheBoVGGEKbm9tA2cIjZ3c5r3ensThSV0aB6MjmONK6CHeE%252FQHgHWeWe5DccHn2GXPWLMalGu2bph5cT2YTXxU78E%252BuAJGE7%252BTsrOCi2YGaMy1nXHBG8La0%252FJVxJA%252F&encrypt=0&l=New+York%2C+NY&query_category_id=400000",
  "description": "Description:<p> </p><p>Pure Power Engineering is seeking a Field Structural Engineer with extensive on-site experience to support our rapidly growing solar engineering portfolio. This role is ideal for a hands-on engineer who excels at evaluating existing structures in the field, understanding a wid",
  "salary": {},
  "benefits": [
    "Health Insurance",
    "Retirement Benefit"
  ],
  "workType": "Full Time",
  "workLocation": "hybrid",
  "category": {
    "major": "Engineering",
    "minor": "Engineering Electrical Engineer"
  },
  "techCategory": {
    "major": "Construction",
    "minor": "Construction Civil Engineer"
  },
  "requirements": [],
  "applyType": "Easy Apply",
  "coordinates": {
    "lat": 40.737377,
    "lng": -74.028305
  },
  "companyLogo": "https://media.j2c.com/company-logos/1927659-pure_power_engineering-e4d194f0",
  "relevanceScore": 0.994941
}
```

***

## Use Cases

### 📊 Job Market Intelligence

Analyze demand trends across job categories and locations.

### 🧠 Salary Research

Build datasets for compensation benchmarking.

### 🏢 Recruitment Automation

Feed structured job data into ATS or CRM systems.

### 🌍 Remote Work Tracking

Monitor remote job availability globally.

### 📈 Workforce Analytics

Study hiring trends across industries and skills.

***

## Performance & Scalability

- Concurrent keyword processing (Semaphore controlled)
- Async HTTP request handling
- Exponential retry backoff for stability
- Batched dataset writes (optimized I/O)
- Pagination-aware scraping engine

Designed for medium-to-large scale job data extraction.

***

## Architecture

### Concurrency Model

- Multiple keywords processed in parallel
- Controlled concurrency via semaphore
- Sequential pagination per keyword (safe against rate limits)

***

## Reliability Features

- Automatic retry on:
  - 429 (rate limit)
  - 403 (blocked requests)
  - 5xx server errors
- Exponential backoff strategy
- Graceful failure handling per keyword
- Partial success support (non-blocking execution)

***

## Best Practices

- Use 2–5 keywords per run for optimal performance
- Use realistic location filters
- Schedule periodic runs for monitoring use cases

***

## SEO Keywords

Job scraper, job listings scraper, job API scraper, job data extractor, job market dataset, recruitment scraper, remote job scraper, salary data scraper, hiring trends scraper, workforce analytics scraper.

***

## Common Users

- Recruiters
- HR tech companies
- Data analysts
- AI dataset builders
- Job board aggregators
- Market research firms

***

## Support

This actor is actively maintained and designed for production scraping workflows on Apify.

For issues or improvements, use the Apify platform issue tracker.

# Actor input Schema

## `keywords` (type: `string`):

List of keywords separated by commas to search for on Jobs2Careers (e.g., software engineer, marketing manager).

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

Location to search for jobs (e.g., New York, NY OR Los Angeles, CA ...).

## `benefit` (type: `array`):

Select benefits to filter job listings. You can select multiple benefits.

## `workType` (type: `array`):

Select work types to filter job listings. You can select multiple work types.

## `date` (type: `string`):

Select the time period for job postings.

## `salary_period` (type: `string`):

Select the salary period to filter job listings.

## `commute` (type: `string`):

Select the maximum commute time to filter job listings.

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

Maximum number for each query to retrieve.

## Actor input object example

```json
{
  "keywords": "software engineer, marketing manager",
  "location": "New York, NY",
  "maxItems": 200
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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("gauzy_penguin/jobs2careers-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("gauzy_penguin/jobs2careers-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 '{}' |
apify call gauzy_penguin/jobs2careers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobs2Careers Scraper",
        "description": "Scrapes job listings from Jobs2Careers search results. Supports keyword search, locations, and various filters.",
        "version": "1.0",
        "x-build-id": "LzrkouPGwBPRiG3i6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gauzy_penguin~jobs2careers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gauzy_penguin-jobs2careers-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/gauzy_penguin~jobs2careers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-gauzy_penguin-jobs2careers-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/gauzy_penguin~jobs2careers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-gauzy_penguin-jobs2careers-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",
                "required": [
                    "location"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "string",
                        "description": "List of keywords separated by commas to search for on Jobs2Careers (e.g., software engineer, marketing manager).",
                        "default": "software engineer, marketing manager"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search for jobs (e.g., New York, NY OR Los Angeles, CA ...).",
                        "default": "New York, NY"
                    },
                    "benefit": {
                        "title": "Benefits",
                        "type": "array",
                        "description": "Select benefits to filter job listings. You can select multiple benefits.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "healthcare",
                                "pto",
                                "education",
                                "childcare",
                                "retirement"
                            ]
                        }
                    },
                    "workType": {
                        "title": "Work Type",
                        "type": "array",
                        "description": "Select work types to filter job listings. You can select multiple work types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "parttime",
                                "workfromhome",
                                "gig",
                                "noexperience",
                                "internship"
                            ]
                        }
                    },
                    "date": {
                        "title": "Date Posted",
                        "enum": [
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Select the time period for job postings."
                    },
                    "salary_period": {
                        "title": "Salary Period",
                        "enum": [
                            "hourly",
                            "weekly",
                            "yearly",
                            "bonus"
                        ],
                        "type": "string",
                        "description": "Select the salary period to filter job listings."
                    },
                    "commute": {
                        "title": "Commute Time",
                        "enum": [
                            "15",
                            "30",
                            "45",
                            "60"
                        ],
                        "type": "string",
                        "description": "Select the maximum commute time to filter job listings."
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 200,
                        "type": "integer",
                        "description": "Maximum number for each query to retrieve.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```