# Ashby Jobs Lookup — Live Postings by Company (`accountable_eel/ashby-jobs-lookup`) Actor

Look up any company's live Ashby job board and get every open role — title, department, team, location, remote status, employment type, apply link. Paste company slugs or careers URLs, press Start. Charged once per company checked, no matter how many roles it has open — none open costs nothing.

- **URL**: https://apify.com/accountable\_eel/ashby-jobs-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 successful lookups

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

## Ashby Jobs Lookup — Live Postings by Company

Look up any company's live [Ashby](https://ashbyhq.com) job board and get every open role back as
one row per posting — title, department, team, location, remote status, employment type, and a
direct apply link. No API key, no HTML scraping: this reads Ashby's own public posting API
directly, so it doesn't break when a careers page gets a redesign. You can also filter the roles
you get back (title keyword, location, remote-only, posted-after date) and put the actor on a
schedule for a hiring-alert delta mode that returns only postings that appeared since your last
run.

### Who it's for

The accountable\_eel catalogue sells company intelligence columns for outbound. Each actor takes a
list of domains or company identifiers and returns one flat, stably-named row per input —
firmographics, registry IDs, tech stack, email route, hiring activity — the shape a Clay table, an
n8n workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event and
per-domain: a few tenths of a cent for a row that was actually found, and nothing for a
miss, so a list that doesn't enrich costs you next to nothing. Where an official source exists —
VIES, GLEIF, SEC EDGAR, Brønnøysund, PRH, RDAP — it is queried directly instead of scraped. No
seat licence, no monthly minimum, no credit system to decode.

This one is the "hiring column": paste a list of companies known to run on Ashby, and get their
current headcount demand back as a table instead of forty open browser tabs.

### Why this one

- **Direct from Ashby's own API**, not a scrape of the rendered careers page — no HTML selectors
  to break when a company redesigns its job board.
- **You pay per company checked, never per job.** A board with 80 open roles and a board with 2
  cost the same single `item-lookup` charge.
- **Real filters, not just a wall of raw fields.** Title keyword include/exclude, location,
  remote-only, and posted-after date all combine, and every filtered-out role still shows up in
  `totalJobCount` so a small result is never ambiguous.
- **A delta mode built for schedules.** Turn on `onlyNewSinceLastRun` and every run after the
  first returns only the postings you haven't seen — a hiring alert, not a re-dump.
- **Ashby's richer job shape kept intact.** Department *and* team, an explicit remote flag, and
  employment type are each their own column instead of being flattened into one free-text field.

### What you get

Every row carries the shared envelope every actor in this catalogue uses, plus the Ashby-specific
fields pulled from `.actor/profile.json`. Which of the posting-level fields (`title` through
`applyUrl`) are present depends on the output shape you pick in the Input tab — see
[How to use](#how-to-use).

| Field | Type | Description |
|---|---|---|
| `query` | string | The input exactly as given — the slug or the careers URL you pasted |
| `found` | boolean | `true` if the company has an Ashby board with at least one open role |
| `status` | string | `OK` on a found row; `NOT_FOUND` or `BAD_FORMAT` on a miss |
| `company` | string | The Ashby slug, extracted from your input and lowercased |
| `jobCount` | number | Roles in this row's result — after filters, and after delta if `onlyNewSinceLastRun` is on |
| `totalJobCount` | number | Open roles on the board before any filter was applied |
| `newJobs` | number | Roles new since your last run — `null` unless `onlyNewSinceLastRun` is on |
| `firstRun` | boolean | Whether this was the baseline run for this watchlist — `null` unless `onlyNewSinceLastRun` is on |
| `jobs` | array | The full matching job list for this company — present only in **one row per company** mode |
| `title` | string | Job title — present only in **one row per job posting** mode (the default) |
| `department` | string | Ashby's `department` field for the posting |
| `team` | string | Ashby's `team` field — a finer-grained grouping than department, when the company uses it |
| `location` | string | The posting's primary location string, as Ashby reports it |
| `isRemote` | boolean | Ashby's own raw `isRemote` flag — `true`, `false`, or absent (shown as empty) when the company never set it |
| `remote` | boolean | Best-effort merged remote flag: trusts `isRemote === true`, otherwise falls back to a location/title check |
| `employmentType` | string | Full-time, part-time, contract, intern, etc., as Ashby classifies it |
| `publishedAt` | string (ISO 8601) | When Ashby published the posting |
| `postedAt` | string (ISO 8601) | Alias of `publishedAt` — Ashby doesn't expose a separate first-published date, unlike Greenhouse |
| `applyUrl` | string (link) | Direct apply link for the posting |
| `scrapedAt` | string (ISO 8601) | Timestamp of the lookup |
| `message` | string | Present only on miss rows — the reason `found` is `false` |

Two fields are deliberately not returned: compensation ranges (Ashby doesn't expose them on every
board, so the column would be mostly empty) and Ashby's `secondaryLocations` array — only the
primary `location` string comes through, to keep this actor's shape consistent with the other
single-platform ATS actors in this portfolio.

### Price

$5 per 1,000 companies, plus a $0.0001 start fee. Misses (`found:false`) are never charged.

You're charged one `item-lookup` per company where at least one open role was found — a board with
hundreds of roles costs the same as one with a handful. A company with no Ashby board, or zero
open roles, comes back `found: false` and costs nothing. A company whose board exists but whose
roles all got filtered out (or had nothing new since your last run) still gets charged — the
lookup happened and answered a real question, it just returned zero matching rows this time.

1,000 companies through this actor: **~$5** if every one is found, less if some aren't — that's
the FREE-tier rate; it drops on paid Apify tiers. The same 1,000 rows through a credit-based
enrichment platform: **$80–$400**.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `companies` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~ashby-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"companies":["ramp"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "companies": [
    "ramp"
  ]
}
```

One company per line — paste the Ashby slug or the full careers page URL. Accepted formats: ramp, https://jobs.ashbyhq.com/ramp.

Don't know a company's Ashby slug? Paste their careers page URL instead —
`jobs.ashbyhq.com/<slug>` works directly, and the slug is pulled out automatically.

**Filtering the roles you get back.** All of these live in the **🎯 Job filters** section of the
Input tab and are optional — leave them empty and you get every open role, exactly as before.

| Input | What it does |
| --- | --- |
| `titleKeywords` | Keep only roles whose **title** contains at least one of these. Case-insensitive, partial words count — `"engineer"` matches *Engineering Manager*. Any-match: `["engineer","designer"]` keeps both kinds. |
| `excludeTitleKeywords` | Drop any role whose title contains one of these — `["intern","contract"]`. Applied after `titleKeywords`, so a role matching both is dropped. |
| `locations` | Keep only roles whose location contains one of these — `["Berlin","United Kingdom"]`. Case-insensitive, partial matches count, any-match. |
| `remoteOnly` | Keep only roles that read as remote. Matches Ashby's own `isRemote` flag when a company has set it, plus *remote*, *anywhere*, *work from home*, *wfh* and *distributed* in the location, and the word *remote* in the title. |
| `postedAfter` | Keep only roles Ashby **first published** on or after this date — `"2026-06-01"`, or a full ISO timestamp. Inclusive of the date you give. |

Different filters combine with **AND** (title *and* location *and* remote); values inside one
filter combine with **OR**. Filtering happens before rows are built, so it applies identically
whether you're getting one row per job or one row per company.

```json
{
  "companies": ["ramp", "notion"],
  "titleKeywords": ["engineer", "designer"],
  "excludeTitleKeywords": ["intern"],
  "locations": ["Remote", "New York"],
  "postedAfter": "2026-06-01"
}
```

`jobCount` and `totalJobCount` come back on every row so a filtered result is never ambiguous. A
company whose roles all get filtered out still gets one `found: true` row with `jobCount: 0` — a
real question was asked and answered, so it's charged like any other company.

**Two output shapes.** Turn off "One row per job posting" in the Input tab to get one row per
company instead, with the full matching job list nested inside `jobs`. Filters apply identically
to both shapes.

**Watching for new jobs.** Turn on `onlyNewSinceLastRun` and put the actor on a schedule to get a
hiring alert instead of a full dump every time:

- The **first run** returns everything that matches your filters and remembers which postings it
  showed you.
- **Every run after that** returns only postings it hasn't shown you before. `newJobs` says how
  many, `firstRun` says whether this was the baseline run.
- A company with **nothing new still gets a row** — `found: true`, `jobCount: 0`, `newJobs: 0` —
  so a quiet week reads as quiet, not as a broken schedule. Every company checked is charged once
  either way.

The seen-list lives in a key-value store named `ashby-jobs-lookup-state` in your own Apify
account, one entry per company. Two things worth knowing: your filters are part of a watchlist's
identity, so two schedules with different `titleKeywords` keep separate seen-lists, and changing a
filter starts a fresh watchlist (the next run re-baselines). A role that closes and later gets
re-posted counts as new again, since the seen-list only ever tracks postings currently on the
board.

### Sample output

By default you get **one row per open job posting** (turn off "One row per job posting" in the
Input tab for one row per company instead, with the full job list nested inside):

| query | found | status | company | jobCount | totalJobCount | newJobs | firstRun | jobs | title | department | team | location | isRemote | remote | employmentType | publishedAt | postedAt | applyUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ramp | true | OK | ramp | 136 | 136 |  |  | \<all matching jobs (full list)> |  Security Engineer, Cloud | Engineering | Backend | New York, NY (HQ) | true | true | FullTime | 2026-04-07T17:12:35.753+00:00 | 2026-04-07T17:12:35.753+00:00 | https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application | 2026-08-24T06:01:25.519Z |

A real row looks like:

| query | found | status | company | title | department | team | location | isRemote | applyUrl |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ramp | true | OK | ramp | Security Engineer, Cloud | Engineering | Backend | New York, NY (HQ) | false | https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245 |

A company with no Ashby board, or no open roles right now, gets a single row with `found: false`
and a `status`/`message` explaining why — and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~ashby-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"companies":["ramp"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~ashby-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"companies":["ramp"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~ashby-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"companies":["{{company}}"]}`, mapping the row's company into the `companies` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Ashby Jobs Lookup | Apify" — the agent will find and run this actor.

### Tips

- **Confirm the platform first if you're not sure.** If your list is mixed across ATS platforms,
  run it through `ats-jobs-unified-lookup` first to see which companies are on Ashby before
  spending a call here on a company that isn't.
- **Use `onlyFound` (in the Output tab) to drop misses from the dataset entirely** if you only
  want companies with an active board — you're not charged for them either way, this just keeps
  the table clean.
- **Set `titleKeywords` before you schedule a delta watchlist.** Changing filters later resets the
  seen-list and re-baselines, so decide on the roles you care about up front.
- **`postedAfter` filters on Ashby's publish date, not on when you happened to run the actor.** A
  role posted last month won't show up just because today is the first time you checked.
- **Pair `remoteOnly` with a location filter for "remote in a specific region.**" `remoteOnly`
  alone catches anything Ashby or the posting itself calls remote, worldwide.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`ashby-jobs-lookup`) | $0.005 per company whose board is found (less on paid tiers), $0.0001 actor start, nothing for a company with no Ashby board | Every open role on a company's Ashby board — title, department, team, location, remote status, employment type, apply link — filtered by title keyword, location, remote-only or posting date, with `onlyNewSinceLastRun` for a hiring-alert delta | Ashby only. If your list is mixed-ATS, use `ats-jobs-unified-lookup`. Ashby's `secondaryLocations` array and compensation ranges aren't returned — only the primary `location` string, matching how the other single-platform ATS actors in this portfolio handle it. |
| **TheirStack** | $0.005–$0.03 per company | A job-postings dataset with history, normalised across many ATS platforms and job boards | Broader coverage than one platform, and it keeps history. This reads Ashby's own API live, at the bottom of that price range. |
| **Ashby's own API** | Free | The same JSON | It is the same JSON. This handles the slug/URL parsing, title and location filtering, remote detection, delta watchlists, and the retries — and hands you a flat table instead of a raw payload. |
| **Clay** | $0.08–$0.40 per enriched row in credits, on top of a seat | A whole enrichment workspace — waterfalls across dozens of providers, plus the table and the sequencing around it | If you want one place that does everything and you're not counting rows, that's Clay. This is one column, priced per column, callable *from* Clay via its HTTP step. |

Prices for third-party tools are their published list prices as of August 2026 and are not tracked
here — check the vendor before relying on the comparison.

### FAQ

**Why does a row come back `found: false`?**
Either the input doesn't look like an Ashby slug or URL (`status: BAD_FORMAT`), or that company
doesn't have an Ashby board, or currently has zero open roles (`status: NOT_FOUND`). Check the
`message` column for the specific reason.

**Am I charged for a miss?**
No. You're only charged for a company where at least one open role was found on its board. A
company with no board, or no current openings, is free — check `status` to see which case you hit.

**Why was I charged for a company that came back with `jobCount: 0`?**
Because its board exists and has open roles — they just didn't match your filters, or (in delta
mode) weren't new since your last run. `totalJobCount` shows how many were actually on the board.
Only a company with no board at all, or literally nothing open, comes back `found: false` and free.

**Does the delta ("new since last run") state cost anything or leak between users?**
It lives in a named key-value store inside your own Apify account, so nobody else can see it and
its storage cost is negligible — a list of posting IDs per company. Delete the
`ashby-jobs-lookup-state` store to reset every watchlist back to a first run.

**Does this respect rate limits, and can I run it against a large list?**
Yes — requests are made one company at a time against Ashby's own posting API with the standard
retry handling built into every actor in this portfolio. There's no published per-account rate
limit from Ashby for this endpoint, but very large lists will simply take longer, not fail.

**Is this GDPR-safe to run against EU companies?**
The data returned is what the company itself published on its own public Ashby-hosted job board —
job titles, locations, and apply links, no candidate or personal data. No data is retained between
runs unless you turn on `onlyNewSinceLastRun`, in which case only posting IDs (not personal data)
are kept in your own account's key-value store.

**Can I run this on a schedule?**
Yes — Apify's built-in Scheduler runs any actor on a cron-style schedule. Combine that with
`onlyNewSinceLastRun` for a recurring hiring alert instead of a recurring full dump.

**Can an AI agent call this directly?**
Yes — it's registered on Apify's MCP server, so an MCP-aware agent (Claude, Cursor, etc.) can find
and run it by name, or you can call the REST API directly as shown above.

**Does this only cover companies that use Ashby?**
Yes. Companies on a different applicant-tracking system won't resolve here — see
`greenhouse-jobs-lookup`, `lever-jobs-lookup`, `workday-jobs-lookup`, `personio-jobs-lookup`, or
`ats-jobs-unified-lookup` for those.

### Related actors

- [ATS Jobs Unified Lookup](https://apify.com/accountable_eel/ats-jobs-unified-lookup)
- [Greenhouse Jobs Lookup](https://apify.com/accountable_eel/greenhouse-jobs-lookup)
- [Workday Jobs Lookup](https://apify.com/accountable_eel/workday-jobs-lookup)
  </content>

# Actor input Schema

## `companies` (type: `array`):

One company per line — paste the Ashby slug or the full careers page URL. Accepted formats: ramp, https://jobs.ashbyhq.com/ramp. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `titleKeywords` (type: `array`):

Optional. Keep only roles whose title contains at least one of these words — e.g. "engineer", "account executive", "designer". Case doesn't matter, and partial words work ("engineer" matches "Engineering Manager"). Leave empty to keep every role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior", "contract". Applied after the include list above, so a role matching both is dropped.

## `locations` (type: `array`):

Optional. Keep only roles whose location mentions one of these — e.g. "Berlin", "New York", "United Kingdom". Case doesn't matter and partial matches work. Leave empty to keep every location.

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

Keep only roles whose location or title says remote (also matches "anywhere", "work from home", "distributed"). Companies label remote work inconsistently, so treat this as a strong filter, not a guarantee.

## `postedAfter` (type: `string`):

Optional. A date like 2026-06-01 (or a full timestamp). Keeps only roles Ashby first published on or after this date. Leave empty for no date limit.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on for a scheduled watchlist: the first run returns everything that matches and remembers it, and every run after that returns only postings it hasn't shown you before. A company with nothing new still gets a row (with 0 jobs), so a quiet schedule never looks like a broken one. Changing the filters above starts a fresh watchlist.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its company. You're still only charged once per company, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "companies": [
    "ramp"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": [],
  "remoteOnly": false,
  "postedAfter": "",
  "onlyNewSinceLastRun": false,
  "columns": [
    "company",
    "jobCount",
    "totalJobCount",
    "newJobs",
    "firstRun",
    "jobs",
    "title",
    "department",
    "team",
    "location",
    "isRemote",
    "remote",
    "employmentType",
    "publishedAt",
    "postedAt",
    "applyUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "companies": [
        "ramp"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/ashby-jobs-lookup").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 = {
    "companies": ["ramp"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/ashby-jobs-lookup").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 '{
  "companies": [
    "ramp"
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": []
}' |
apify call accountable_eel/ashby-jobs-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/ashby-jobs-lookup"
        }
    }
}

```

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/OFGj52fyeVZlBQf4Y/builds/yzMZp2RwBswfgi0ii/openapi.json