# Welcome to the Jungle Jobs | $2.49 / 1k | (`glasswing/welcome-to-the-jungle-jobs`) Actor

Scrape Welcome to the Jungle job offers by keyword, city or contract type. Get company, office and coordinates, contract type, experience, education, salary range and publication date. Export to CSV, JSON or Excel.

- **URL**: https://apify.com/glasswing/welcome-to-the-jungle-jobs.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

Get every opening on Welcome to the Jungle as a clean spreadsheet row: job title, company, office city with geo coordinates, contract type, remote policy, salary range, required experience and publication date. Built for recruiters sourcing in France, talent teams benchmarking pay, job aggregators syndicating listings and analysts tracking the European tech hiring market.

Scrape Welcome to the Jungle jobs by keyword, city, country, contract type or remote status — or paste one company page and pull every vacancy that company currently advertises. This is an HTTP-only scraper: no browser, no login, no proxy setup. One request returns up to 100 European job listings with salary and location data, so a 500-offer pull finishes in seconds and exports to CSV, JSON, Excel or XML.

**Fast by design:** a measured local run collected **500 offers in 7 seconds using 5 requests**. The default 20-offer preview run takes about 7 seconds.

### What does this Welcome to the Jungle jobs scraper do?

It searches the public Welcome to the Jungle job index and saves one row per job offer.

You can point it at:

- **a search URL** — `https://www.welcometothejungle.com/en/jobs?query=data%20analyst` (any language prefix works: `/en/`, `/fr/`, `/es/`)
- **a company page** — `https://www.welcometothejungle.com/en/companies/alan` returns every offer that company currently advertises
- **or no URL at all** — just type a keyword, a location, a contract type and a remote toggle

Filters written into a search URL (keyword, city, country, contract type, remote) are read and applied. The filter fields fill in anything a URL does not already specify.

Every row carries a `status` field so you always know what happened:

| `status` | Meaning | Billed |
|---|---|---|
| `ok` | A job offer was extracted. | Yes |
| `not_found` | The search ran fine but matched no offers. | No |
| `error` | The source could not be read; `error` explains why. | No |

You are never charged for a `not_found` or `error` row.

### Use cases for Welcome to the Jungle job data

- **Recruiters sourcing in France.** Pull every open data, product or engineering role in Paris, Lyon or Nantes with its contract type and remote policy, then work the list company by company instead of clicking through a job board all afternoon.
- **Salary benchmarking.** Collect a few thousand offers for one profession and read `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` to see what employers actually advertise for a role, by city and seniority, before you write an offer or ask for a raise.
- **Startup job tracking.** Watch a shortlist of company pages on a schedule; a jump in openings is a hiring-intent signal a sales or investment team can act on weeks before a funding announcement makes the news.
- **Job boards and aggregators.** Syndicate French and European job listings into your own site with a stable schema — `jobId`, `title`, `companyName`, `city`, `countryCode`, `contractType`, `publishedAt` and a canonical `jobUrl` to link back to.
- **Labour-market research.** Analysts and journalists track remote-work adoption, contract-type mix and hiring seasonality across the French tech market using `remote`, `contractType` and `publishedAt` over repeated runs.
- **Candidate-side job search automation.** Run a daily search for your criteria and push new offers to Slack or a Google Sheet, so you see roles the morning they are published rather than the week after.

### What data you get from every job listing

One row per offer. Fields the employer did not publish are simply absent — never guessed.

#### Identity and links

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Stable identifier of the offer in the source index. |
| `reference` | string | Employer's own reference for the offer. |
| `slug` | string | URL slug of the offer. |
| `title` | string | Job title as published. |
| `jobUrl` | string | Public job page URL. Same value as `url`. |
| `url` | string | Public job page URL (the base column every factory Actor carries). |

#### Company

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Hiring company name. |
| `companySlug` | string | Company slug used in the company page URL. |
| `companyUrl` | string | Public company profile URL. |
| `companyLogo` | string | Company logo image URL. |
| `companySize` | number | Headcount reported on the company profile. |
| `sectors` | array | Business sectors of the company, e.g. `["Software","Cyber Security"]`. |

#### Location

| Field | Type | Description |
|---|---|---|
| `city` | string | Office city. |
| `district` | string | Office district or department. |
| `state` | string | Office region or state. |
| `country` | string | Office country name. |
| `countryCode` | string | ISO-3166 alpha-2 country code, e.g. `FR`. |
| `latitude` | number | Office latitude (WGS84). |
| `longitude` | number | Office longitude (WGS84). |
| `offices` | array | All locations as `"City, Country"` strings, present only when the offer lists more than one. |

#### Contract, experience and salary

| Field | Type | Description |
|---|---|---|
| `contractType` | string | `FULL_TIME`, `PART_TIME`, `TEMPORARY`, `INTERNSHIP`, `APPRENTICESHIP`, `FREELANCE`, `VIE` or `OTHER`. |
| `contractTypeName` | string | Human-readable label in English, e.g. `Full-Time`. |
| `contractDurationMin` | number | Minimum contract duration in months, for time-boxed offers. |
| `contractDurationMax` | number | Maximum contract duration in months. |
| `remote` | string | Remote policy: `fulltime`, `partial`, `punctual`, `no` or `unknown`. |
| `experienceLevelMin` | number | Minimum years of experience requested. |
| `educationLevel` | string | Education level code, e.g. `BAC_5`. |
| `salaryMin` | number | Lower bound of the advertised salary range. |
| `salaryMax` | number | Upper bound of the advertised salary range. |
| `salaryCurrency` | string | ISO currency code, e.g. `EUR`. |
| `salaryPeriod` | string | Period the salary refers to, e.g. `yearly` or `monthly`. |
| `salaryYearlyMin` | number | Yearly-normalised lower bound computed by the source. |

#### Context and bookkeeping

| Field | Type | Description |
|---|---|---|
| `publishedAt` | string | Publication timestamp of the offer (ISO 8601). |
| `language` | string | Language the offer is written in (ISO 639-1). |
| `department` | string | Internal department named by the employer. |
| `profession` | string | Profession label, e.g. `Data Analysis`. |
| `professionCategory` | string | Profession category, e.g. `Tech`. |
| `profile` | string | Candidate-requirements text, converted from the source HTML to plain text. |
| `promoted` | boolean | True when the employer paid to promote the offer. |
| `searchQuery` | string | The keyword this row was found with. |
| `status` | string | `ok`, `not_found` or `error`. |
| `error` | string | Reason, on `not_found` and `error` rows only. |
| `scrapedAt` | string | ISO 8601 timestamp of extraction. |

The dataset ships two views: **💼 Job offers** (the columns most runs need) and **📋 All fields**.

### How to scrape Welcome to the Jungle jobs

**1. Choose what to search** 🔍 — paste one or more Welcome to the Jungle search or company URLs into **Search URLs or company slugs**, or leave that list empty and type a **Keyword** instead.

**2. Narrow it down** 🎯 — optionally set **Location** (city, country name or two-letter code), **Contract type** and **Remote-friendly only**.

**3. Set the run size** ⚙️ — **Maximum results** caps how many offers you pay for. Start at 20 for a preview.

**4. Run it** ▶️ — rows appear in the dataset in real time. Export to CSV, Excel, JSON or XML, or read them from the API.

### Input

| Field | Type | Default | When to change it |
|---|---|---|---|
| `startUrls` | array of strings | one example search URL: `https://www.welcometothejungle.com/en/jobs?query=data%20analyst` | Replace it with your own search URLs, or with company page URLs to pull one employer's whole job list. Leave it empty if you would rather describe the search with the fields below. |
| `query` | string | empty | Set a free-text keyword such as `data analyst` or `python` when you are not pasting URLs. Leave empty to get everything matching the other filters. |
| `location` | string | empty | Set a city, country name or two-letter code (`Paris`, `France`, `FR`) to restrict results to one market. Leave empty to search everywhere the index covers. |
| `contractType` | select | any | Pick one of `FULL_TIME`, `PART_TIME`, `TEMPORARY`, `INTERNSHIP`, `APPRENTICESHIP`, `FREELANCE`, `VIE`, `OTHER` when you only want one kind of contract, e.g. internships for a campus-hiring list. |
| `remoteOnly` | boolean | `false` | Turn it on to keep only offers advertising full or partial remote work. |
| `maxItems` | integer | `20` | Raise it for production runs; each `ok` row is one billable result, so this is also your spending cap. |
| `maxResults` | integer (hidden) | unset | API and agent alias of `maxItems`. Only useful if your client already sends this name; ignored when `maxItems` is set. |
| `proxyConfiguration` | object | off | Leave off. Enable Apify Proxy only if you ever see repeated request failures; residential proxies are not needed. |

#### Example input

```json
{
    "startUrls": ["https://www.welcometothejungle.com/en/jobs?query=data%20analyst"],
    "maxItems": 20,
    "remoteOnly": false,
    "proxyConfiguration": { "useApifyProxy": false }
}
```

Keyword-only, with filters:

```json
{
    "query": "product manager",
    "location": "Paris",
    "contractType": "FULL_TIME",
    "remoteOnly": true,
    "maxItems": 100
}
```

### Output

One JSON object per offer. This is a real row from a run of the default input, unedited:

```json
{
    "url": "https://www.welcometothejungle.com/en/companies/natixis/jobs/stage-6-mois-data-analyst-f-h_charenton-le-pont_NATIX_5l5qazL",
    "status": "ok",
    "scrapedAt": "2026-09-08T11:43:02.072Z",
    "jobId": "4265372",
    "reference": "NATIX_5l5qazL",
    "slug": "stage-6-mois-data-analyst-f-h_charenton-le-pont_NATIX_5l5qazL",
    "title": "Stage - 6 mois - Data Analyst - F/H",
    "jobUrl": "https://www.welcometothejungle.com/en/companies/natixis/jobs/stage-6-mois-data-analyst-f-h_charenton-le-pont_NATIX_5l5qazL",
    "companyName": "Natixis",
    "companySlug": "natixis",
    "companyUrl": "https://www.welcometothejungle.com/en/companies/natixis",
    "companyLogo": "https://cdn-images.welcometothejungle.com/9RcfPrSxYl22FytP8WgrtlX9Ae34A4q5sHd5f4v9wjU/w:200/q:85/czM6Ly93dHRqLXBy/b2R1Y3Rpb24vdXBs/b2Fkcy9vcmdhbml6/YXRpb24vbG9nby8y/NDE3LzE1MjI5My9i/ODk5ZmE2ZC1mNTRi/LTQyYjktYWI2Mi1k/ZDA4ZTFlZDRmMGEu/anBn",
    "companySize": 13600,
    "city": "Charenton-Le-Pont",
    "district": "Val-de-Marne",
    "state": "Ile-de-France",
    "country": "France",
    "countryCode": "FR",
    "latitude": 48.82283,
    "longitude": 2.40332,
    "contractType": "INTERNSHIP",
    "contractTypeName": "Internship",
    "contractDurationMin": 6,
    "contractDurationMax": 6,
    "remote": "no",
    "experienceLevelMin": 0,
    "educationLevel": "BAC_3",
    "salaryCurrency": "EUR",
    "salaryPeriod": "yearly",
    "publishedAt": "2026-09-08T10:00:00.000+02:00",
    "language": "fr",
    "sectors": ["Banking", "Change Management", "Insurance"],
    "profile": "Étudiant de niveau BAC+3/4/5, vous préparez un diplôme (universitaire, d'école de commerce ou d'école d'ingénieur), avec une spécialisation en Finance. …",
    "promoted": false,
    "searchQuery": "data analyst"
}
```

A row that found nothing looks like this and costs nothing:

```json
{
    "url": "https://www.welcometothejungle.com/en/jobs?query=zzzqxwv-no-such-job-title-anywhere-42",
    "status": "not_found",
    "error": "No job offers match \"zzzqxwv-no-such-job-title-anywhere-42\"",
    "scrapedAt": "2026-09-08T11:47:12.153Z"
}
```

### How much does it cost?

Pay per event. No subscription.

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.005 | Once per run (Apify charges one event per GB of memory, minimum one; the default 1 GB means one event). |
| Job offer | $0.00249 | One offer with `status: ok` saved to the dataset. |

Rows with `status: not_found` or `error` are **never charged**. That works out at **$2.49 per 1,000 offers** plus half a cent per run.

| Run | Cost |
|---|---|
| Default preview (20 offers) | $0.055 |
| 100 offers | $0.254 |
| 1,000 offers | $2.50 |

The Actor stops gracefully when your run's maximum charge is reached, so a spending limit is never exceeded.

### How it compares

This Actor is built for depth on one job board rather than breadth across many. Because it reads the site's public search index instead of rendering pages, it is fast and cheap and it returns structured attributes a page scraper would have to infer: salary bounds with currency and period, contract duration in months, education level, office geo coordinates and a machine-readable remote policy. It is a good fit if your market is France, the French-speaking countries or European tech hiring in general.

It is not the right tool if you need a multi-board aggregate feed, if your hiring market is North America or Asia (coverage there is thin), if you need the full job description rather than the candidate-requirements text, or if you are looking for recruiter contact details — it returns none, by design.

### Integrations, API and AI agents

Results export to CSV, JSON, Excel and XML from the Apify console, or flow straight into **Google Sheets, Airtable, Slack or your CRM** through Apify integrations and webhooks — including Make, Zapier and n8n. Schedule the Actor to run every morning and only new rows are pushed downstream.

It can be called from the **Apify API**, from any Apify client library, from the **Apify MCP server**, or by any AI agent that can call an HTTP endpoint. Every row carries a `status` column, so an agent can tell "nothing matched" apart from "the request failed" without parsing prose.

```bash
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&format=csv"
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const { defaultDatasetId } = await client.actor('welcome-to-the-jungle-jobs').call({
    query: 'data analyst',
    location: 'Paris',
    maxItems: 100,
});
const { items } = await client.dataset(defaultDatasetId).listItems();
```

### Limitations

Honest notes so nothing surprises you:

- **Coverage is strongest in France.** The index held about 85,000 live offers when this was written, of which roughly 79,000 were in France. Spain, the United Kingdom, the United States, Germany, Canada, Belgium and Italy each contribute a few hundred to a thousand. Outside Europe the coverage is thin.
- **This uses an unofficial, undocumented endpoint.** The Actor reads the same public search index the website's own front end queries. That interface can change shape or be withdrawn without notice.
- **The public search keys rotate.** The site publishes its search-only credentials at a public endpoint; the Actor reads them at the start of every run and only falls back to the pair captured at build time if that endpoint is unreachable or has changed shape. The run log always states which of the two was used. If the site rotates its keys *and* changes that endpoint at the same time, the Actor needs a rebuild — the run will fail loudly rather than return empty.
- **`profile`, not the full description.** The search index carries the candidate-requirements text, not the complete job description. About a third of offers include it. The full description lives only on the job page, which is rendered in the browser and is not fetched by this Actor.
- **Many fields are optional.** Salary appears on a minority of offers, and experience, education, department and profession are frequently absent. An absent field means the employer did not publish it.
- **`remote: unknown` is common.** It means the employer did not state a remote policy, not that the job is on-site.
- **Search depth.** The Actor follows up to 100 pages per search; with 100 offers per page that is 10,000 offers for a single search. Split very large jobs by location or contract type.
- **One contract type per search.** To collect two contract types, run two searches or pass two start URLs.

### FAQ

**Do I need an account or a login?** No. Only publicly visible job offers are read; nothing behind a login is touched.

**Do I need proxies?** No. The Actor is HTTP-only and works from Apify's datacenter IPs, which is why proxy support is off by default. You can turn on Apify Proxy if you ever see repeated request failures.

**How fast is it, and how many jobs can I pull?** One request returns up to 100 offers. A measured local run collected 500 offers in 7 seconds with 5 requests and no failures. A single search can be followed to 10,000 offers; split bigger jobs by city or contract type.

**Can I get every job for one company?** Yes — pass the company page URL, for example `https://www.welcometothejungle.com/en/companies/alan`, and raise `maxItems`.

**Which countries does it cover?** France by a wide margin, then Spain, the United Kingdom, Germany, Belgium, Italy, Canada and the United States. Use `location` with a city name, a country name or a two-letter code.

**Why is `salaryMin` missing on most rows?** Most employers on this site do not publish a salary. The Actor reports what is published and leaves the rest out rather than estimating.

**What does `remote: punctual` mean?** Occasional remote work — a day here and there. The **Remote-friendly only** filter keeps just `fulltime` and `partial`.

**Why did my run fail with "No job offers with status ok"?** The search matched nothing, or the source could not be read. That is deliberate: an empty run fails loudly instead of quietly returning zero rows. Check the `not_found` or `error` row in the dataset for the reason.

**Is the job description included?** The candidate-requirements text (`profile`) is included when published. The full description is not part of the search index.

**Can I schedule it?** Yes. Use Apify Schedules and store results in a named dataset, or push them to Sheets, Airtable or a CRM through an integration.

### Legal and privacy

This Actor collects **only publicly available job-advertisement and company data**. It is an independent tool and is not affiliated with, endorsed by, or connected to Welcome to the Jungle or its operators. All trademarks belong to their respective owners.

- ✅ **No personal data.** The Actor never extracts recruiter or contact names, e-mail addresses or phone numbers. Company identities are business information, not personal data.
- ✅ **No login, no private pages.** Only anonymous, publicly reachable content is read.
- ✅ **No protection is circumvented.** The Actor reads a public search interface with the credentials the site itself publishes, and stays within polite request rates.
- ✅ **Business data only.** Output describes companies and vacancies.
- ✅ **Lawful purposes only.** Use the data in line with GDPR and any other law that applies to you.
- ✅ **You are the controller.** You decide what you collect, how long you keep it and what you do with it. Review the target site's terms before large-scale or commercial use.

If you believe a record should not be published here, contact Apify support and it will be reviewed.

***

Found a bug or want another field? Open an issue on the Actor's page — and if it saved you time, a ⭐ review helps a lot.

# Actor input Schema

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

Welcome to the Jungle URLs, one per line. Accepts search pages (https://www.welcometothejungle.com/en/jobs?query=data%20analyst) and company pages (https://www.welcometothejungle.com/en/companies/alan), in any language prefix (/en/, /fr/, /es/). A company URL returns every offer that company currently advertises. Filters written into the URL (keyword, city, country, contract type) are honoured; the fields below fill in whatever a URL does not already specify.

## `query` (type: `string`):

Free-text search term, e.g. "data analyst", "product manager", "python". Matches the job title, the company and the offer text. Leave empty to get every offer that matches the filters below.

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

City, country name or two-letter country code, e.g. "Paris", "France" or "FR". Matched against the office of the offer. Coverage is strongest in France, then the rest of Europe.

## `contractType` (type: `string`):

Restrict to one contract type. Leave empty for any. VIE is the French international corporate volunteering scheme.

## `remoteOnly` (type: `boolean`):

Keep only offers that advertise full or partial remote work. Offers marked "punctual", "no" or "unknown" are excluded.

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

Stop after this many rows have been saved. Each saved row with status `ok` is one billable result. One HTTP request returns up to 100 offers, so raising this stays fast.

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

Hidden alias of `maxItems` for API and agent callers that use this name. Ignored when `maxItems` is set.

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

Optional. The Actor is HTTP-only and works from Apify's datacenter IPs without a proxy, which is why this is off by default. Enable Apify Proxy only if you see repeated request failures; residential proxies are not needed for this Actor.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.welcometothejungle.com/en/jobs?query=data%20analyst"
  ],
  "remoteOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.welcometothejungle.com/en/jobs?query=data%20analyst"
    ],
    "remoteOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/welcome-to-the-jungle-jobs").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": ["https://www.welcometothejungle.com/en/jobs?query=data%20analyst"],
    "remoteOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/welcome-to-the-jungle-jobs").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 '{
  "startUrls": [
    "https://www.welcometothejungle.com/en/jobs?query=data%20analyst"
  ],
  "remoteOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/welcome-to-the-jungle-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/welcome-to-the-jungle-jobs"
        }
    }
}

```

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/KaocvOC7fgVF6rMaj/builds/NQdrJqwhh5qMdRBQI/openapi.json