# JobTeaser Scraper (`runtime/jobteaser-scraper`)

JobTeaser Scraper is an Apify Actor that scrapes job listings from JobTeaser, including company names, job titles, locations, and contract types.

- **URL**: https://beta-securitybyobscurity.apify.com/runtime/jobteaser-scraper.md
- **Developed by:** [scraping automation](https://beta-securitybyobscurity.apify.com/runtime) (community)
- **Categories:** Jobs, Lead generation, Integrations
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$29.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

# README

## 🚀 JobTeaser Scraper

**JobTeaser Scraper** is an Apify Actor that scrapes job listings from JobTeaser, including company names, job titles, locations, and contract types.

### Features

- ✅ **Scrapes company names, job titles, locations, and contract types.**
- ✅ **Dynamic pagination that continues until the job limit is reached.**
- ✅ **Advanced anti-detection measures to avoid blocking.**
- ✅ **Optimized with batch processing for large scrapes.**
- ✅ **Integrated with Apify Proxy for reliable access.**
- ✅ **Stores data in Apify Dataset for easy export.**

### Input Parameters

| Parameter       | Type      | Description                                           | Default Value                        |
|---------------|---------|---------------------------------------------------|----------------------------------|
| `startUrls`   | `array`  | List of JobTeaser job pages to scrape.            | `https://www.jobteaser.com/fr/job-offers` |
| `jobsMax` | `integer` | Target number of job listings to scrape. The scraper will attempt to reach this number, but might collect fewer if blocked by the website. | `50` |
| `jobQuery` | `string` | Optional search term for jobs (e.g. 'developer', 'marketing'). | \`\` |
| `batchSize` | `integer` | Number of jobs to collect before pushing to the dataset (reduces memory usage for large scrapes). | `20` |
| `useApifyProxy` | `boolean` | Whether to use Apify Proxy for scraping. | `true` |
| `proxyConfiguration` | `object` | Optional proxy configuration for advanced settings. | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }` |

### Website Limitations

JobTeaser implements progressive anti-bot measures that may limit the number of pages accessible in a single run. In testing, the scraper was typically able to reliably access 2-3 pages (40-60 jobs) before encountering blocking.

For best results:

- Keep `jobsMax` reasonable (50-100 is recommended)
- Use residential proxies
- Consider running multiple smaller scrapes rather than one large scrape
- The scraper will intelligently handle blocking and continue to the next pages when possible

### Output

The scraped job listings are stored in an Apify Dataset as structured JSON:

```json
[
  {
    "company": "JobTeaser",
    "title": "Business Developer (M/F/D)",
    "link": "https://www.jobteaser.com/fr/job-offers/652e4f99-9a2f-4454-8dfa-511fb8163c42",
    "contract": "CDI",
    "location": "Cologne, Germany"
  },
  {
    "company": "Accenture",
    "title": "Data Scientist",
    "link": "https://www.jobteaser.com/fr/job-offers/7a1e3f88-8b2f-4454-7gfa-511fb8163c42",
    "contract": "CDI",
    "location": "Paris, France"
  }
]
```

### Anti-Detection Features

This scraper implements advanced techniques to avoid being blocked:

- Residential proxy rotation
- User-agent rotation
- Human-like browsing behavior simulation
- Request throttling and random delays
- Browser fingerprint randomization
- Session persistence and management

***

#### ⚠️ Legal Disclaimer

This project is intended for educational and research purposes only. The use of this Actor must comply with JobTeaser's Terms of Service and robots.txt policies.

You are responsible for ensuring your use case does not violate JobTeaser's website terms.

### Related Resources: Job boards

- [Upwork Job Scraper](https://apify.com/runtime/welcome-to-the-jungle-job-scraper)
- [Hellowork Job Scraper](https://apify.com/runtime/hellowork-job-scraper)
- [Welcome To The Jungle Job Scraper](https://apify.com/runtime/welcome-to-the-jungle-job-scraper)
- [BOF Business Of Fashion Careers Job Scraper](https://apify.com/runtime/bof-business-of-fashion-careers-job-scraper)

# Actor input Schema

## `startUrls` (type: `array`):

URLs to start scraping from. The scraper will continue adding pages until jobsMax is reached.

## `jobQuery` (type: `string`):

Search term for jobs (e.g. 'developer', 'marketing')

## `jobsMax` (type: `integer`):

Target number of jobs to scrape. The scraper will attempt to reach this number, but might collect fewer if blocked by the website.

## `paginationMax` (type: `integer`):

DEPRECATED: No longer used. The scraper will continue pagination until jobsMax is reached.

## `batchSize` (type: `integer`):

Number of jobs to collect before pushing to the dataset (reduces memory usage for large scrapes).

## `useApifyProxy` (type: `boolean`):

Whether to use Apify Proxy

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

Configure the proxy settings for scraping (Use Apify proxies to avoid blocking).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.jobteaser.com/fr/job-offers"
    }
  ],
  "jobsMax": 50,
  "paginationMax": 999,
  "batchSize": 20,
  "useApifyProxy": true,
  "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 = {
    "startUrls": [
        {
            "url": "https://www.jobteaser.com/fr/job-offers"
        }
    ],
    "useApifyProxy": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("runtime/jobteaser-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 = {
    "startUrls": [{ "url": "https://www.jobteaser.com/fr/job-offers" }],
    "useApifyProxy": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("runtime/jobteaser-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 '{
  "startUrls": [
    {
      "url": "https://www.jobteaser.com/fr/job-offers"
    }
  ],
  "useApifyProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call runtime/jobteaser-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobTeaser Scraper",
        "description": "JobTeaser Scraper is an Apify Actor that scrapes job listings from JobTeaser, including company names, job titles, locations, and contract types.",
        "version": "0.2",
        "x-build-id": "HM3QChn2GHtIAz9E9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/runtime~jobteaser-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-runtime-jobteaser-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/runtime~jobteaser-scraper/runs": {
            "post": {
                "operationId": "runs-sync-runtime-jobteaser-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/runtime~jobteaser-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-runtime-jobteaser-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start scraping from. The scraper will continue adding pages until jobsMax is reached.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "jobQuery": {
                        "title": "Job Search Query",
                        "type": "string",
                        "description": "Search term for jobs (e.g. 'developer', 'marketing')"
                    },
                    "jobsMax": {
                        "title": "Maximum Jobs to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Target number of jobs to scrape. The scraper will attempt to reach this number, but might collect fewer if blocked by the website.",
                        "default": 50
                    },
                    "paginationMax": {
                        "title": "Maximum Pages to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "DEPRECATED: No longer used. The scraper will continue pagination until jobsMax is reached.",
                        "default": 999
                    },
                    "batchSize": {
                        "title": "Batch Size",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Number of jobs to collect before pushing to the dataset (reduces memory usage for large scrapes).",
                        "default": 20
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Whether to use Apify Proxy",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure the proxy settings for scraping (Use Apify proxies to avoid blocking)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
