# Recruitee (Tellent) Jobs Lookup: Live Postings by Company (`accountable_eel/recruitee-tellent-jobs-lookup`) Actor

Look up any company's live Recruitee or Tellent job board: title, location, department, remote status, apply link. Works for classic subdomains and custom Tellent careers domains alike. Filter by title, location, remote, or posted date, or watch only for new postings. Charged once per company.

- **URL**: https://apify.com/accountable\_eel/recruitee-tellent-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, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

## Recruitee (Tellent) Jobs Lookup — Live Postings by Company

You paste a list of companies. For each one, this actor looks up their live **Recruitee** or
**Tellent** job board and returns every open role — title, location, department, remote status,
and apply link — as one row per posting (or one row per company, your choice). No API key, no HTML
scraping: it reads the board's own public Careers Site API directly. Optional filters narrow the
roles you get back by title, location, remote, or posting date, and an optional delta mode returns
only the 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-company: 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. Here, the "identifier" is a Recruitee subdomain
or a Tellent careers-site domain, and the "row" is a job posting — useful for sourcing candidates,
watching a competitor's hiring, or tracking headcount signal across a target list.

### Why this one

- **Covers both careers-site shapes, not one.** Recruitee rebranded/merged into "Tellent" in 2026,
  and companies migrating their careers page end up in one of two places: a classic
  `<token>.recruitee.com` subdomain, or a fully custom Tellent-hosted domain
  (e.g. `careers.tellent.com`). This actor accepts either — a bare subdomain token or a custom
  domain / full careers URL — and resolves both the same way. Most single-target scrapers assume
  one URL shape and quietly miss the other half of this ATS's install base.
- **Direct from the board's own public API.** No HTML scraping to break when a careers page gets
  redesigned — this calls the same `/api/offers/` endpoint the careers page's own JavaScript does,
  unauthenticated and unchanged by the rebrand.
- **You pay per company, not per job.** A board with 20 open roles and a board with 2 both cost one
  `item-lookup` charge. A company with no board, or zero open roles, is a free miss.
- **Real filters, not a wall of raw fields.** Title keyword include/exclude, location, remote-only,
  and posted-after-date all combine, so you can ask for exactly the roles you want.
- **`remote` is a real boolean Recruitee computes, plus a text fallback.** Most ATS scrapers in this
  family have to guess remote status from a location string. Recruitee ships `remote`/`hybrid`/
  `on_site` booleans on every posting — better ground truth — but companies still tag it
  inconsistently, so a role a company mistagged `remote:false` that clearly says "remote" in its
  title or location is still caught by the same text fallback the rest of this actor's job-board
  siblings use.
- **A delta mode for watching hiring over time.** Turn on `onlyNewSinceLastRun`, put the actor on a
  schedule, and every run after the first returns only postings you haven't seen — a quiet week
  still gets a row, so you can tell "nothing new" from "the run broke."

### What you get

One row per open job posting by default (toggle "One row per job posting" off in the Input tab to
get one row per company instead, with the full job list nested in `jobs`). Every row carries these
fields, whether or not you've turned on filters or delta mode — the columns never move:

| Field | Type / format | Description |
| --- | --- | --- |
| `query` | text | The company value you passed in, unchanged. |
| `found` | boolean | `true` if the company has a Recruitee/Tellent board with at least one open role, `false` otherwise. |
| `status` | text | `OK`, `NOT_FOUND` (no board, or no open roles), or `BAD_FORMAT` (input didn't look like a token, domain, or URL). |
| `boardToken` | text | The host actually queried — either `<token>.recruitee.com` (from a bare token) or the custom domain you passed in. |
| `jobCount` | number | How many roles matched, after your filters (and after delta filtering, if `onlyNewSinceLastRun` is on). |
| `totalJobCount` | number | How many roles were on the board before any filtering — lets you see what a filter dropped. |
| `newJobs` | number | How many roles are new since your last scheduled run. Empty unless `onlyNewSinceLastRun` is on. |
| `firstRun` | boolean | `true` if this was the baseline run for this watchlist. Empty unless `onlyNewSinceLastRun` is on. |
| `jobs` | array | The full list of matching jobs, each with the fields below. Present in every row; expanded into separate rows in "one row per job" mode. |
| `title` | text | Job title. |
| `location` | text | Location as Recruitee lists it (e.g. "Amsterdam, Noord-Holland, Netherlands"). |
| `departments` | array | Department name for the role, wrapped in an array (Recruitee's own field is a single string). |
| `remote` | boolean | `true` if Recruitee's own `remote` flag is set, or if the location/title reads as remote as a fallback (matches "remote", "anywhere", "work from home", "wfh", "distributed" in the location, or the word "remote" in the title). |
| `postedAt` | date (ISO) | When the posting was first published (`published_at`, falling back to `created_at`), normalized from Recruitee's non-standard `"YYYY-MM-DD HH:MM:SS UTC"` timestamp format into real ISO-8601. |
| `updatedAt` | date (ISO) | When the posting was last edited, same normalization. |
| `applyUrl` | link | Direct apply link for the role (`careers_apply_url`, falling back to `careers_url`). |
| `scrapedAt` | date (ISO) | When this actor fetched the row. |

A company with no Recruitee/Tellent board, or with a board but zero open roles, still comes back as
one row with `found: false` and a `status`/`message` explaining why — and that row is never
charged.

### Price

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

However many roles a found company has open, it's one charge: a board with dozens of postings costs
the same as one with two.

### 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~recruitee-tellent-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"companies":["bunq"]}'
   ```
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.

Paste one company per line, in either of two accepted forms:

- a bare Recruitee subdomain token, like `bunq` (resolves to `bunq.recruitee.com`)
- a custom careers-site domain or full careers URL, for companies that moved to a Tellent-hosted
  domain — like `careers.tellent.com` or `https://careers.bunq.com/o/some-job`

Both forms are looked up the same way automatically; you don't need to know which kind a company
uses before pasting it in.

To narrow the roles you get back, open the **🎯 Job filters** section of the Input tab. All of these
are optional and combine with AND across fields, OR within a field:

| Input | What it does |
| --- | --- |
| `titleKeywords` | Keep only roles whose title contains at least one of these — `["engineer","designer"]`. Case-insensitive, partial words count. |
| `excludeTitleKeywords` | Drop roles whose title contains one of these — `["intern","contract"]`. Applied after `titleKeywords`. |
| `locations` | Keep only roles whose location contains one of these — `["Amsterdam","United Kingdom"]`. |
| `remoteOnly` | Keep only roles that read as remote — Recruitee's own flag first, text fallback second. |
| `postedAfter` | Keep only roles first published on or after this date — `"2026-06-01"`. |

Leave every filter empty and you get every open role. A company whose roles all get filtered out
still returns a `found: true` row with `jobCount: 0`, charged like any other found company, because
it answered the question you asked.

For a standing watchlist, turn on **`onlyNewSinceLastRun`** in the **🔁 Watch for new jobs** section
and put the actor on a schedule. The first run baselines (returns everything matching your filters,
`firstRun: true`); every run after that returns only postings it hasn't shown you before, counted in
`newJobs`. A quiet run still returns a row per company (`jobCount: 0`, `newJobs: 0`) so you can tell
"nothing new" from "the run failed." Two schedules with different filter values keep separate
seen-lists automatically.

### Input

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

One company per line. Two accepted forms: a bare Recruitee subdomain token (e.g. "bunq" for bunq.recruitee.com), or a custom careers-site domain / full careers URL for companies that moved to a Tellent-hosted custom domain (e.g. "careers.tellent.com" or "https://careers.bunq.com/o/some-job"). Both forms are looked up the same way automatically. Accepted formats: bunq, https://bunq.recruitee.com, careers.tellent.com.

### Sample output

| query | found | status | boardToken | jobCount | totalJobCount | newJobs | firstRun | jobs | title | location | departments | remote | postedAt | updatedAt | applyUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| bunq.recruitee.com | true | OK | bunq.recruitee.com | 10 | 10 |  |  | \<all matching jobs (full list)> | Technology Risk Officer | Amsterdam, Noord-Holland, Netherlands | \["Risk, Legal & Compliance"] | false | 2026-08-10T11:14:25Z | 2026-08-26T14:46:56Z | https://careers.bunq.com/o/technology-risk-officer/c/new | 2026-08-31T07:00:46.405Z |

In "one row per job posting" mode (the default), a real row for `bunq` looks like:

| query | found | status | boardToken | title | location | departments | remote | applyUrl |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| bunq | true | OK | bunq.recruitee.com | Technology Risk Officer | Amsterdam, Noord-Holland, Netherlands | \["Risk, Legal & Compliance"] | true | https://careers.bunq.com/o/technology-risk-officer/c/new |

### 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~recruitee-tellent-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"companies":["bunq"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~recruitee-tellent-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"companies":["bunq"]}` (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~recruitee-tellent-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 "Recruitee (Tellent) Jobs Lookup | Apify" — the agent will find and run this actor.

### Tips

- **Paste whichever form you actually have.** If you only know a company uses Recruitee, the bare
  token works. If you found their careers page and it's on a custom domain, paste the URL directly
  — you never need to hunt for the underlying subdomain token.
- **Combine filters to build a watchlist query, not just a keyword search.** `titleKeywords: ["engineer"]` plus `locations: ["Amsterdam"]` gets you Amsterdam-based engineering roles only, in
  one pass.
- **Put delta mode on a weekly schedule for competitor tracking.** `onlyNewSinceLastRun` plus a
  fixed company list turns this into a hiring-alert feed.
- **Trust `remote`, but verify with `location` on roles that matter.** Recruitee gives real booleans,
  which beats guessing from text — but companies still tag hybrid/on-site roles inconsistently, so
  the field is a strong signal, not a guarantee.
- **Switch to one-row-per-company mode when you just want a headcount number.** Turn off "One row
  per job posting" and read `jobCount` per company.
- **Don't combine delta mode with "Only keep rows containing."** That filter runs on the finished
  row and can drop the `newJobs: 0` heartbeat row.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`recruitee-tellent-jobs-lookup`) | Charged once per company whose board is found, nothing for a company with no board | Every open posting for a company's Recruitee or Tellent board — title, location, department, remote status, apply URL — filtered by role keyword, location, or posting date, with `onlyNewSinceLastRun` for deltas | Recruitee/Tellent only. If your list is mixed-ATS, use `ats-jobs-unified-lookup`. |
| **Recruitee/Tellent's own API** | Free | The same JSON | It is the same JSON. This handles the two-shape subdomain/custom-domain resolution, timestamp normalization, filtering, deltas, and retries, and hands you a flat table. |
| **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 `found` say false, or a row come back empty?**
Either the input didn't look like a Recruitee token, Tellent domain, or URL (`status: BAD_FORMAT`),
the company doesn't have a Recruitee/Tellent board, or it currently has zero open roles
(`status: NOT_FOUND` either way). Check the `message` column for the specific reason.

**Was I charged for that row?**
Only if `found` is `true`. A company with no board, or no current openings, is free — check `status`
to confirm which case it was.

**I got charged for a company that returned `jobCount: 0` — why?**
Because its board exists and has open roles — they just didn't match your filters, or weren't new
since your last delta run. `totalJobCount` shows how many were actually on the board before
filtering. That's a real answer to the question you asked, so it's billed like any other found
company. A company with no board at all, or nothing open, comes back `found: false` and is never
charged.

**How does the delta / "new since last run" state work, and can I reset it?**
It lives in a named key-value store, `recruitee-tellent-jobs-lookup-state`, inside your own Apify
account — nobody else can see it, and its storage cost is negligible. Delete that store to reset
every watchlist. Changing your filters also starts a fresh watchlist automatically.

**Why is a company's board on `careers.tellent.com` instead of `<company>.recruitee.com`?**
Recruitee rebranded/merged into "Tellent" in 2026. Companies that migrated their careers page fully
moved to a Tellent-hosted custom domain; companies that didn't are still on their original
`*.recruitee.com` subdomain, unchanged. Both serve the same `/api/offers/` shape, which is why this
actor accepts either input form.

**Why doesn't `postedAt` look like the raw Recruitee timestamp?**
Recruitee's API returns dates like `"2026-08-10 11:14:25 UTC"` — a space-separated format with a
literal "UTC" suffix, not standard ISO-8601. This actor normalizes it to `"2026-08-10T11:14:25Z"`
before it ever reaches your output or a `postedAfter` comparison, since raw `Date.parse()` handling
of Recruitee's exact format is inconsistent across JavaScript engines.

**Does this actor hit rate limits on large company lists?**
It calls the board's public Careers Site API once per company, with its own timeout and retry
handling. The API is unauthenticated and public, the same one each company's own careers page
calls — this actor doesn't need proxies to reach it.

**Is this GDPR-safe to run against companies in the EU?**
The data returned is what each company has already published publicly on its own careers page — job
titles, locations, departments, apply links. No personal data about applicants or employees is
collected. As with any lookup, you're responsible for how you use the output downstream.

**Can I run this on a schedule?**
Yes — set up an Apify schedule against this actor with your company list as input. Combine it with
`onlyNewSinceLastRun` for a hiring-alert feed, or leave it off to get a fresh full dump every run.

**Can an AI agent call this directly?**
Yes — it's registered with the Apify MCP server. An agent with that MCP connected can find and run
"Recruitee (Tellent) Jobs Lookup" by name and get dataset rows back without you writing any
integration code; see [Use it from Clay, n8n, Make, or an AI agent](#use-it-from-clay-n8n-make-or-an-ai-agent).

### Related actors

- [ATS Jobs Unified Lookup](https://apify.com/accountable_eel/ats-jobs-unified-lookup) — check a
  company across Greenhouse, Lever, Ashby, and other ATS platforms in one call when you don't know
  which one they use.
- [Greenhouse Jobs Lookup](https://apify.com/accountable_eel/greenhouse-jobs-lookup) — the same
  lookup, filters, and delta mode for companies on Greenhouse.
- [Lever Jobs Lookup](https://apify.com/accountable_eel/lever-jobs-lookup) — the same lookup,
  filters, and delta mode for companies on Lever.

# Actor input Schema

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

One company per line. Two accepted forms: a bare Recruitee subdomain token (e.g. "bunq" for bunq.recruitee.com), or a custom careers-site domain / full careers URL for companies that moved to a Tellent-hosted custom domain (e.g. "careers.tellent.com" or "https://careers.bunq.com/o/some-job"). Both forms are looked up the same way automatically. Accepted formats: bunq, https://bunq.recruitee.com, careers.tellent.com. 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. "Amsterdam", "New York", "United Kingdom". Case doesn't matter and partial matches work. Leave empty to keep every location.

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

Keep only roles Recruitee itself marks remote, or whose location or title says remote (also matches "anywhere", "work from home", "distributed"). Companies tag remote work inconsistently even with a real boolean available, 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 Recruitee first published on or after it — useful for "what opened up this month". 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": [
    "bunq"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "locations": [],
  "remoteOnly": false,
  "postedAfter": "",
  "onlyNewSinceLastRun": false,
  "columns": [
    "boardToken",
    "jobCount",
    "totalJobCount",
    "newJobs",
    "firstRun",
    "jobs",
    "title",
    "location",
    "departments",
    "remote",
    "postedAt",
    "updatedAt",
    "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": [
        "bunq"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/recruitee-tellent-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": ["bunq"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "locations": [],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/recruitee-tellent-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/VjTVftDk31Y7QAWbP/builds/7UYgKlO8JRcqevsDt/openapi.json