# Djinni Jobs Scraper (`parsebird/djinni-jobs-scraper`) Actor

Scrape tech job listings from Djinni.co by keyword, location, experience, English level, and remote status. Get titles, companies, salaries, descriptions, and required skills, with incremental change monitoring. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/parsebird/djinni-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 job 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/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

### Djinni Jobs Scraper

Scrape tech job listings from **[Djinni.co](https://djinni.co)** — the largest job board for developers, QA, designers, and IT specialists in Ukraine and Eastern Europe — into clean, structured JSON. The Djinni Jobs Scraper pulls the job title, company, full description, salary, required experience, English level, industry, remote status, and view and application counts from any keyword search, with no login and no Djinni API.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search Djinni by keyword, then filter by location, years of experience, English level, remote status, salary, company, and domain — get 40+ structured fields per job, the full description in text, HTML, and Markdown, and incremental change monitoring for scheduled runs.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Actor: parsebird/djinni-jobs-scraper (Apify). Scrapes tech jobs from djinni.co. Call with ApifyClient.
Input JSON fields:
  query: string[] - keyword(s) to search, e.g. ["python","golang"]. Empty = browse all tech jobs.
  location: string[] - city/country/region kept if the listing location text matches (post-fetch)
  startUrls: string[] - Djinni search URLs (https://djinni.co/jobs/keyword-python/) or job URLs (https://djinni.co/jobs/820617-.../)
  experienceLevel: string[] - keep listings asking exactly N years, values "0".."10" (post-fetch)
  englishLevel: string[] - CEFR levels A1,A2,B1,B2,C1,C2 (post-fetch)
  isRemote: bool (default false) - keep full-remote listings only
  employmentType: string[] - FULL_TIME, PART_TIME (post-fetch)
  companyName: string[] / domain: string[] - substring filters on company / industry (post-fetch)
  salaryFrom / salaryTo: int USD - drop listings whose published salary range is out of bounds; 0 = off
  postedWithinDays: int - freshness filter; 0 = any age
  includeKeywords / excludeKeywords: { keywords: string[], matchTitle: bool, matchDescription: bool }
  scrapeDetails: bool (default false) - open each job page for required languages, required skills, company profile URL
  compact: bool (default false) - core fields only, for LLM/agent pipelines
  maxResults: int (default 25) - primary cost cap; billed rows. 0 = unlimited
  maxPages: int (default 5) - max search pages per query (15 jobs/page)
  incrementalMode: bool + stateKey: string - emit only NEW/UPDATED/REAPPEARED jobs vs the last run
  emitUnchanged / emitExpired / skipReposts: bool - monitoring row toggles
  proxyConfiguration: { "useApifyProxy": true }
Output: one dataset item per job - jobKey, title, company, companyUrl, companyLogo, location, description,
  descriptionHtml, descriptionMarkdown, salaryText, salaryMin, salaryMax, salaryCurrency, employmentType,
  industry, category, experienceMonths, experienceYears, englishLevel, requiredLanguages, requiredSkills,
  isRemote, remoteText, directApply, postedAt, validThrough, viewsCount, applicationsCount, canonicalUrl,
  contentHash, changeType, firstSeenAt, lastSeenAt, isRepost.
Example: { "query": ["python"], "maxResults": 50 }
API: https://api.apify.com/v2/acts/parsebird~djinni-jobs-scraper  ·  Token: https://console.apify.com/account/integrations
```

### What does Djinni Jobs Scraper do?

[Djinni](https://djinni.co) is where thousands of product companies, outsourcers, and startups post remote and on-site tech roles — Python, JavaScript, Go, Java, .NET, QA, DevOps, data, design, and management. There is no public Djinni API — this Djinni scraper is the alternative. It extracts:

- 💼 **Job basics** — title, hiring company, company logo, company website, company type (Product, Outsource, Agency), and the job's own Djinni URL.
- 📝 **Full description** — the complete job posting in plain text, original HTML, and Markdown, plus a character count.
- 💰 **Salary** — the relative salary marker (`$` to `$$$$`) shown on the card, and the exact `salaryMin` / `salaryMax` / currency when the company publishes a range.
- 📈 **Requirements** — years of experience (as months and years), the CEFR English level (B2, C1, …), and — with `scrapeDetails` — the full required-languages list and the required-skills experience breakdown.
- 🌍 **Location & remote** — the applicant location text, the applicant region and country from the structured data, and a `full remote` / `office` / `hybrid` classification.
- 🏭 **Context** — the industry / domain (fintech, gamedev, gambling, healthcare), employment type, "actively hiring" and "confirmed hires" flags, and live view and application counts.
- 🔁 **Change tracking** — incremental mode tags every row `NEW`, `UPDATED`, `UNCHANGED`, `REAPPEARED`, or `EXPIRED` and detects reposts of expired listings.

Common uses: building a tech-jobs aggregator, tracking hiring demand by stack or seniority, salary benchmarking for Eastern Europe, sourcing companies that hire remotely, and feeding a job-alert or LLM pipeline.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| query | array of strings | No | `["python"]` | Keyword(s) to search. Each entry runs its own search. Empty browses all jobs. |
| location | array of strings | No | — | City / country / region kept if the listing location matches. Applied after fetching. |
| startUrls | array of strings | No | — | Djinni search URLs or job detail URLs. Scraped in addition to `query`. |
| experienceLevel | array of strings | No | — | Keep listings asking exactly N years (`0`–`10`). Applied after fetching. |
| englishLevel | array of strings | No | — | Keep listings requiring one of these CEFR levels (`A1`–`C2`). Applied after fetching. |
| isRemote | boolean | No | `false` | Keep full-remote listings only; drop office and hybrid roles. |
| employmentType | array of strings | No | — | Keep `FULL_TIME` and/or `PART_TIME` listings. |
| companyName | array of strings | No | — | Keep listings whose company name contains one of these values. |
| domain | array of strings | No | — | Keep listings whose industry / category contains one of these values. |
| salaryFrom / salaryTo | integer | No | `0` | Drop listings whose published salary range is out of bounds (USD). `0` disables. |
| postedWithinDays | integer | No | `0` | Keep listings published within N days. `0` allows any age. |
| includeKeywords | object | No | — | `{ "keywords": ["react","node"], "matchTitle": true, "matchDescription": true }` — require at least one. |
| excludeKeywords | object | No | — | Same shape — drop listings that contain any. |
| scrapeDetails | boolean | No | `false` | Open every job page for the required-languages list, required-skills experience, and company profile URL. |
| compact | boolean | No | `false` | Return only core fields, for LLM / AI-agent pipelines. |
| maxResults | integer | No | `25` | Maximum job listings to return. Primary cost control — billed rows. `0` = unlimited. |
| maxPages | integer | No | `5` | Maximum search pages per query (15 jobs per page). |
| incrementalMode | boolean | No | `false` | Return only jobs that are new or changed since the last run with the same `stateKey`. |
| stateKey | string | No | `default` | Separates one watchlist or schedule from another. |
| emitUnchanged / emitExpired / skipReposts | boolean | No | `false` | Monitoring row toggles. |
| proxyConfiguration | object | No | Apify Proxy | Proxy settings. Djinni works over automatic Apify Proxy. |

#### Example inputs

Basic search — keyword-driven search with a result cap:

```json
{ "query": ["python"], "maxResults": 50 }
```

Filtered search — senior remote roles with strong English:

```json
{
  "query": ["golang", "rust"],
  "isRemote": true,
  "experienceLevel": ["5", "6", "7"],
  "englishLevel": ["B2", "C1", "C2"],
  "maxResults": 100
}
```

Incremental tracking — only emit jobs that changed since the previous run:

```json
{
  "query": ["python"],
  "maxResults": 200,
  "incrementalMode": true,
  "stateKey": "python-tracker"
}
```

Compact filtered output — lightweight records for an AI agent or MCP data source:

```json
{
  "query": ["devops"],
  "experienceLevel": ["3"],
  "maxResults": 50,
  "compact": true
}
```

Direct URLs:

```json
{
  "startUrls": [
    "https://djinni.co/jobs/keyword-java/",
    "https://djinni.co/jobs/820617-senior-python-engineer/"
  ],
  "maxResults": 100
}
```

### What data can you extract from Djinni?

| Field | Description |
|-------|-------------|
| jobKey | Djinni numeric job id |
| jobId | Stable hash of the canonical job URL |
| title | Job title |
| company | Hiring company name |
| companyUrl | Company website |
| companyLogo | Company logo image URL |
| companyType | Product, Outsource, Outstaff, Agency, Startup |
| location | Applicant location text, e.g. "Countries of Europe or Ukraine" |
| applicantRegion / applicantCountry | Region and country from the structured data |
| description / descriptionText | Full job description as plain text |
| descriptionHtml / descriptionMarkdown | Full description as HTML and Markdown |
| salaryText | Relative salary marker (`$`–`$$$$`) shown on the card |
| salaryMin / salaryMax / salaryCurrency / salaryPeriod | Exact published salary range, when the company provides one |
| employmentType | `FULL_TIME` or `PART_TIME` |
| industry / category | Domain (fintech, gamedev, …) and Djinni skill category |
| experienceMonths / experienceYears | Required experience |
| englishLevel | Required CEFR English level (A1–C2) |
| requiredLanguages / requiredSkills | Full language and skill-experience list (with `scrapeDetails`) |
| isRemote / remoteText / jobLocationType | Remote classification and wording |
| directApply | Whether the listing accepts direct applications |
| activelyHiring / companyConfirmedHires | Djinni trust and activity badges |
| postedAt / postedAtRaw / validThrough | Publish timestamp and expiry |
| viewsCount / applicationsCount | Live engagement counts |
| canonicalUrl | The job's page on Djinni |
| extractedUrls / socialProfiles | Links found in the description |
| changeType / firstSeenAt / lastSeenAt / isRepost / repostOfId | Incremental monitoring fields |

### Output example

```json
{
  "jobKey": "846430",
  "title": "Python Backend Developer",
  "company": "Zutobi",
  "companyUrl": "https://zutobi.com/us",
  "companyLogo": "https://p.djinni.co/41/eb2244c706b2fa4a1cc0776c9b1ade/zutobi-dou-1_400.png",
  "companyType": "Product",
  "location": "Countries of Europe or Ukraine",
  "applicantRegion": "Europe",
  "description": "Zutobi is a global edtech product company ...",
  "descriptionMarkdown": "Zutobi is a global edtech product company ...",
  "descriptionLength": 2126,
  "salaryText": "$$$",
  "salaryMin": null,
  "salaryMax": null,
  "employmentType": "FULL_TIME",
  "industry": "edutech",
  "category": "Python",
  "experienceMonths": 36,
  "experienceYears": 3,
  "englishLevel": "B2",
  "requiredLanguages": [
    { "language": "English", "level": "B2", "levelText": "B2 - Upper Intermediate" },
    { "language": "Ukrainian", "level": "B2", "levelText": "B2 - Upper Intermediate" }
  ],
  "isRemote": true,
  "remoteText": "Full Remote",
  "directApply": true,
  "activelyHiring": false,
  "companyConfirmedHires": true,
  "postedAt": "2026-09-03T13:30:26.792615",
  "validThrough": "2026-10-03T13:30:26.792615",
  "viewsCount": 19,
  "applicationsCount": 9,
  "canonicalUrl": "https://djinni.co/jobs/846430-python-backend-developer/",
  "sourceDomain": "djinni.co",
  "sourceCountry": "UA",
  "searchQuery": "python",
  "detailFetched": true,
  "contentQuality": "full",
  "contentHash": "60b11d9eabd65f44290c98061352065ea4e74894863afd05a850105903ae5d4a",
  "changeType": "NEW",
  "firstSeenAt": "2026-09-03T10:00:00.000Z",
  "lastSeenAt": "2026-09-03T10:00:00.000Z"
}
```

Download the dataset as **JSON, CSV, Excel, HTML, or XML** from the Storage tab or the [Apify API](https://docs.apify.com/api/v2).

### Use cases

- **Tech-jobs aggregator** — feed a job board or a Telegram / Slack alert channel with fresh Djinni roles.
- **Hiring-demand tracking** — measure how many jobs open per stack, seniority, or domain over time with incremental mode.
- **Salary benchmarking** — collect published salary ranges for Eastern Europe by role and experience.
- **Remote-friendly company lists** — pull companies posting full-remote roles in a given field.
- **Recruiting & sourcing** — monitor competitors' openings and spot companies scaling a team.
- **LLM & AI agents** — compact, structured job records for retrieval, summarisation, or matching.

### How it works

1. **Build the search** — each `query` becomes a Djinni keyword search; an empty query browses all jobs. `startUrls` are added as-is.
2. **Read the results** — every search-results page carries both a structured `JobPosting` block and the visible cards; the actor merges them per listing, so the full description, salary, experience, and English level come straight from the search page — no extra request per job.
3. **Enrich (optional)** — with `scrapeDetails`, each job page is opened for the required-languages list, required-skills experience, and company profile URL.
4. **Filter** — location, experience, English level, remote, employment type, company, domain, salary, freshness, and include / exclude keyword rules are applied to the collected jobs.
5. **Detect changes (optional)** — in incremental mode the run is compared with the previous run for the same `stateKey`, and only the selected transitions become dataset rows.
6. Rows stream to the dataset and stop at `maxResults`.

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

This actor is **pay per result** — charged once per job saved.

| Plan | Price per 1,000 jobs |
|------|----------------------|
| Free | **$0.99** |
| Bronze | **$0.89** |
| Silver | **$0.89** |
| Gold | **$0.79** |

A small platform **Actor start** fee also applies per run. `maxResults` is the exact number of billed rows. Scraping 1,000 jobs on the Free plan costs about **$0.99**. Apify's monthly free platform usage covers small runs. In incremental mode you are billed only for the change rows that are emitted, not for the full search.

### How to scrape Djinni

1. Click **Try for free** and sign in to Apify.
2. Enter one or more **keywords** (or leave `query` empty to browse all jobs).
3. Add any **filters** — location, experience, English level, remote, salary.
4. Set **maxResults** (start low, e.g. 25).
5. Click **Start**, then watch rows appear in the **Output** tab.
6. Export from **Storage**, or pull results via the API.

#### Run it via API

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("parsebird/djinni-jobs-scraper").call(run_input={
    "query": ["python", "golang"],
    "isRemote": True,
    "maxResults": 100,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "-", job["company"], "-", job.get("salaryText"))
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('parsebird/djinni-jobs-scraper').call({
    query: ['devops'],
    experienceLevel: ['3', '4', '5'],
    maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Schedule recurring runs, add webhooks, or push results to Google Sheets, Slack, Zapier, and Make with [Apify integrations](https://docs.apify.com/platform/integrations).

### FAQ

**Do I need a Djinni account or API key?**
No. The scraper reads public Djinni listing pages only. Djinni has no public jobs API — this actor is the alternative.

**How current is the data?**
Live. Each run reads Djinni at that moment. Use Apify's scheduler with `incrementalMode` to keep a dataset fresh and get only what changed.

**Why is the full job description already in the results without `scrapeDetails`?**
Djinni's search-results pages embed the complete description for every listing, so the actor gets it in one request per page. Turn on `scrapeDetails` only for the required-languages list, required-skills experience, and the company profile URL.

**How do the experience and English filters work?**
They are applied after fetching. `experienceLevel` keeps listings that ask for exactly that many years; `englishLevel` matches the CEFR level shown on the listing. Listings that don't state a value are dropped when the matching filter is set.

**What does `salaryText` mean?**
Djinni shows a relative marker — `$` below average, `$$` average, `$$$` above average, `$$$$` top range — for every job. When a company publishes an actual range, `salaryMin`, `salaryMax`, and `salaryCurrency` are also filled.

**What counts as a billed row?**
Every job saved to the dataset, including incremental change rows. `maxResults` is the cap.

**Something's not working.**
Open an issue on the **Issues** tab with your input and the run link — we respond quickly.

### Is it legal to scrape Djinni?

Scraping publicly available pages is legal in most jurisdictions, and this actor only reads listing pages any visitor can see — no login, no private data. You are responsible for how you use the data — respect Djinni's Terms of Use and applicable law when handling any personal data, and consult a lawyer if you are unsure. See Apify's guide on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Related actors

- [Indeed Jobs Scraper](https://apify.com/parsebird/indeed-jobs-scraper) — job listings from Indeed worldwide.
- [Instahyre Jobs Scraper](https://apify.com/parsebird/instahyre-jobs-scraper) — India tech jobs with employer context.
- [hh.ru Jobs Scraper](https://apify.com/parsebird/hh-ru-jobs-scraper) — vacancies from Russia's largest job board.
- [AllJobs.co.il Jobs Scraper](https://apify.com/parsebird/alljobs-il-scraper) — Israeli job listings with change monitoring.
- [Freelancer.com Scraper](https://apify.com/parsebird/freelancer-com-scraper) — freelance projects and budgets.

Browse all [ParseBird actors](https://apify.com/parsebird) on Apify Store.

# Actor input Schema

## `query` (type: `array`):

Keyword(s) to search for, such as python, java, or devops. Add several entries to run a multi-query batch. Leave empty to browse all tech jobs.

## `location` (type: `array`):

City, country, or region to keep, such as Ukraine, Poland, or Kyiv. Matched against the listing's location text after fetching. Add several entries for a multi-location filter.

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

Direct Djinni search URLs (https://djinni.co/jobs/keyword-python/) or job detail URLs (https://djinni.co/jobs/820617-senior-python-engineer/). When set, these are scraped in addition to the query above.

## `experienceLevel` (type: `array`):

Keep only listings that ask for exactly this many years of experience. Select several for a multi-value filter. Applied after fetching.

## `englishLevel` (type: `array`):

Keep only listings requiring one of these English levels (CEFR). Applied after fetching.

## `isRemote` (type: `boolean`):

Keep only full-remote listings and drop office and hybrid roles.

## `employmentType` (type: `array`):

Keep only listings with one of these employment types. Applied after fetching.

## `companyName` (type: `array`):

Keep only listings whose company name contains one of these values (case-insensitive). Applied after fetching.

## `domain` (type: `array`):

Keep only listings whose industry contains one of these values, such as fintech, gamedev, or healthcare. Applied after fetching.

## `salaryFrom` (type: `integer`):

Drop listings whose published salary range is entirely below this amount (USD). Listings without a published salary are kept. 0 disables the filter.

## `salaryTo` (type: `integer`):

Drop listings whose published salary range is entirely above this amount (USD). Listings without a published salary are kept. 0 disables the filter.

## `postedWithinDays` (type: `integer`):

Keep only listings published within this many days. 0 allows any age.

## `includeKeywords` (type: `object`):

Require at least one of these keywords in the title and/or description. Example: {"keywords": \["react", "node"], "matchTitle": true, "matchDescription": true}.

## `excludeKeywords` (type: `object`):

Drop listings that contain any of these keywords. Same shape as Include keywords.

## `scrapeDetails` (type: `boolean`):

Also open every job page to collect the full required-languages list, the company profile URL, and the exact publish date. Slower and doubles the number of requests. The search results already contain the full job description.

## `compact` (type: `boolean`):

Return only the core fields per job, ideal for feeding an LLM, an AI agent, or an MCP data source without token overhead.

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

Maximum total job listings to return (0 = unlimited). This is the primary cost control - the actor charges per emitted record. Start small and raise it once you have checked the search.

## `maxPages` (type: `integer`):

Maximum search-result pages to scrape per query or start URL (15 jobs per page). A defensive bound - Max results is the primary cap.

## `incrementalMode` (type: `boolean`):

Compare this run with prior runs that use the same state key and return only the jobs that are new or whose tracked content changed.

## `stateKey` (type: `string`):

A stable name that separates one watchlist or schedule from another.

## `emitUnchanged` (type: `boolean`):

Also return jobs that were seen in a previous run and have not changed (changeType UNCHANGED).

## `emitExpired` (type: `boolean`):

Also return jobs that were present in a previous run but have now disappeared from the search (changeType EXPIRED).

## `skipReposts` (type: `boolean`):

Drop listings detected as reposts of a previously expired job with identical content.

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

Djinni serves fine over Apify Proxy. Automatic proxy is enabled by default; switch to residential only if you hit rate limiting on very large runs.

## Actor input object example

```json
{
  "query": [
    "python"
  ],
  "location": [],
  "startUrls": [],
  "experienceLevel": [],
  "englishLevel": [],
  "isRemote": false,
  "employmentType": [],
  "companyName": [],
  "domain": [],
  "salaryFrom": 0,
  "salaryTo": 0,
  "postedWithinDays": 0,
  "includeKeywords": {},
  "excludeKeywords": {},
  "scrapeDetails": false,
  "compact": false,
  "maxResults": 25,
  "maxPages": 5,
  "incrementalMode": false,
  "stateKey": "default",
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": [
        "python"
    ],
    "location": [],
    "startUrls": [],
    "companyName": [],
    "domain": [],
    "salaryFrom": 0,
    "salaryTo": 0,
    "postedWithinDays": 0,
    "includeKeywords": {},
    "excludeKeywords": {},
    "maxResults": 25,
    "maxPages": 5,
    "stateKey": "default",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/djinni-jobs-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 = {
    "query": ["python"],
    "location": [],
    "startUrls": [],
    "companyName": [],
    "domain": [],
    "salaryFrom": 0,
    "salaryTo": 0,
    "postedWithinDays": 0,
    "includeKeywords": {},
    "excludeKeywords": {},
    "maxResults": 25,
    "maxPages": 5,
    "stateKey": "default",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/djinni-jobs-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 '{
  "query": [
    "python"
  ],
  "location": [],
  "startUrls": [],
  "companyName": [],
  "domain": [],
  "salaryFrom": 0,
  "salaryTo": 0,
  "postedWithinDays": 0,
  "includeKeywords": {},
  "excludeKeywords": {},
  "maxResults": 25,
  "maxPages": 5,
  "stateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/djinni-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/djinni-jobs-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/1IDwFRLwBw37dgYgK/builds/dTieMncAEcTQ0l962/openapi.json