# Comeet Careers Jobs API (`zinin/comeet-careers-jobs-api`) Actor

Return bounded factual rows from one buyer-authorized Comeet public careers feed.

- **URL**: https://apify.com/zinin/comeet-careers-jobs-api.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** Jobs
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 published comeet job delivereds

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

## Comeet Careers Jobs API

Turn one buyer-authorized Comeet careers feed into up to 100 normalized factual job rows. The Actor makes one bounded request to the official Careers API, applies deterministic filters, and writes only the selected published-job facts to an Apify Dataset.

![One authorized feed becomes a bounded factual Dataset](https://api.apify.com/v2/key-value-stores/2wMDBiyr0IffjX2Ue/records/comeet-careers-jobs-api-source-workflow.png)

### What you get

- Stable job and source-position IDs for joining snapshots downstream.
- Title, company, department, employment type, experience level, workplace type, coarse public location, remote flag, update time, and public Comeet-hosted job page.
- Token-free source provenance, a rights notice, and a deterministic `changeFingerprint` on every row.
- One predictable source request with closed input, response, byte, time, and result limits.

The Actor ID is `e6wV1MYbPGryoT5ZD`. Public Task `fetch-buyer-authorized-comeet-jobs` (`TdlZaNmMI1avtxcOK`) starts with Comeet's publicly documented mock-data sandbox so it can produce a non-empty demo Dataset. Replace the sandbox UID and token with credentials you are authorized to use before processing a production company feed.

### Who it is for

This Actor fits recruiting operations, careers-site owners, analysts, and automation builders who already have authorized access to one company's Comeet Careers feed and need bounded factual rows. It does not discover credentials, search every Comeet employer, mirror descriptions, rank candidates, or submit applications.

### Quick start

The Console form is prefilled with Comeet's public mock-data sandbox: UID `E5.007` and token `5E7236A0BCE5E7295111B55E70BCE`. Comeet publishes these values specifically for implementations that need mock data. They return sandbox positions and do not authorize access to another company's feed.

For production use, get the company UID and Careers token from that company's Comeet Careers Website settings and replace both prefilled values. The deliberately fictional UID `FICTIONAL.001` below is schema-valid but does not identify a usable feed; replace it together with the token placeholder:

```json
{
  "companyUid": "FICTIONAL.001",
  "companyToken": "REPLACE_WITH_YOUR_COMEET_TOKEN",
  "titleContains": "",
  "departmentContains": "",
  "locationContains": "",
  "remoteOnly": false,
  "maxResults": 25
}
```

The Input Schema marks `companyToken` as secret, including when the public sandbox prefill is used. The Actor uses it only in the single fixed source request; it is excluded from Dataset rows and Actor logs. Both production-example values above require replacement: `FICTIONAL.001` is not a usable company UID, and `REPLACE_WITH_YOUR_COMEET_TOKEN` is not a usable credential. The separate sandbox values are public demo credentials documented by Comeet.

### Input reference

| Field | Required | Meaning |
| --- | --- | --- |
| `companyUid` | Yes | Company UID from the authorized Careers Website settings. The prefill is Comeet's publicly documented mock-data sandbox UID `E5.007`; replace it for production. |
| `companyToken` | Yes | Secret Careers token for the same company. The prefill is Comeet's publicly documented mock-data sandbox token; replace it for production. The runtime accepts 16–200 URL-safe characters. |
| `titleContains` | No | Case-insensitive literal title substring; empty means no title filter. |
| `departmentContains` | No | Case-insensitive literal department substring; empty means no department filter. |
| `locationContains` | No | Literal match across public location name, city, state, country code, and timezone. |
| `remoteOnly` | No | Keep rows the source location or workplace type marks remote. Default: `false`. |
| `maxResults` | No | Deliver at most 1–100 rows after filtering and deterministic sorting. Default: `100`. |

Unknown input fields, malformed IDs or tokens, unsafe control text, and out-of-range limits reject the run as `input_invalid`. Filters are normalized literal text, not regular expressions.

### How it works

1. The Actor validates the closed input before any request or Dataset write.
2. It makes one HTTPS `GET` request to the fixed `www.comeet.co` Careers API company route with `details=false`. Input cannot choose another host, path, port, or protocol.
3. Redirects, non-200 responses, compressed bodies, invalid UTF-8 or JSON, response-shape drift, duplicate position IDs, and oversized responses fail closed.
4. Internal positions are removed. The Actor applies the optional literal filters, sorts by source position ID, and selects at most `maxResults` rows.
5. Each complete selected row is stored in the default Dataset. In Pay Per Event runs, the named `result-found` event is confirmed only after that row's Dataset write succeeds.

There is no browser, proxy, pagination, retry, job-page fetch, application request, or AI enrichment step.

### Output Dataset

![Factual output fields and the paid delivery boundary](https://api.apify.com/v2/key-value-stores/2wMDBiyr0IffjX2Ue/records/comeet-careers-jobs-api-dataset-contract.png)

The `overview` Dataset view exposes the fields useful for reviewing published roles. This field-complete example is from the bounded Comeet public API sandbox canary observed during release; it is evidence of the output contract, not a claim that the vacancy is current:

```json
{
  "schemaVersion": "1.0",
  "source": "comeet-careers-api",
  "sourceName": "Comeet",
  "sourceCompanyUid": "E5.007",
  "sourceApiUrl": "https://www.comeet.co/careers-api/2.0/company/E5.007/positions?details=false",
  "sourceDocumentationUrl": "https://developers.comeet.com/reference/careers-api-overview",
  "sourcePositionId": "E8.91F",
  "jobId": "comeet:E5.007:E8.91F",
  "companyName": "Careers API Sandbox",
  "title": "Android Developer",
  "department": "Engineering",
  "employmentType": "Full-time",
  "experienceLevel": "Entry-level",
  "workplaceType": "On-site",
  "locationName": "New York",
  "city": "Brooklyn",
  "state": "NY",
  "countryCode": "US",
  "timezone": "America/New_York",
  "remote": false,
  "updatedAt": "2020-10-08T16:19:06.000Z",
  "publicPageUrl": "https://www.comeet.com/jobs/careersapi-sandbox/E5.007/android-developer/E8.91F",
  "sourceComplete": true,
  "rightsNotice": "Buyer-authorized Comeet published-careers facts only; descriptions, application email, street/postal details, pictures, token-bearing URLs, candidate data and application submission are excluded.",
  "changeFingerprint": "72f6c1193ed9a29e3324f7a3025370dd0279a84ab28bf568222471872dd1a66d"
}
```

### Field interpretation

- `remote` is true when Comeet's location flag is true or its workplace type contains `remote`; the Actor does not infer remote work from a title or description.
- `sourceApiUrl` is a reconstructed token-free provenance URL. The real request carries the secret token, but output never does.
- `publicPageUrl` is a validated Comeet-hosted public page and remains an inert Dataset value; the Actor never follows it.
- `sourceComplete: true` means the source response passed the Actor's closed validation before filtering. It does not mean all Comeet employers or the whole labour market were covered.
- `changeFingerprint` hashes the normalized factual identity of the row. Store snapshots downstream if you want history or change alerts; this Actor does not retain prior runs.
- An empty Dataset means the source validated but no external published position matched the filters.

### Pricing

The Actor uses Pay Per Event with only the automatic Actor Start and the primary `result-found` event. Actor Start is charged once when a run starts. One `result-found` is charged for each complete row after that row is successfully stored in the default Dataset.

| Tier | Actor start | Each delivered row |
| --- | ---: | ---: |
| FREE | $0.013000 | $0.001000 |
| BRONZE | $0.012350 | $0.000950 |
| SILVER | $0.011700 | $0.000900 |
| GOLD | $0.011050 | $0.000850 |
| PLATINUM | $0.010660 | $0.000820 |
| DIAMOND | $0.010400 | $0.000800 |

Cost is `Actor start + delivered rows × row price`. At FREE prices, the public Task's 25-row cap costs at most **$0.038** and the hard 100-row maximum costs at most **$0.113**. Invalid input, source failure, an incomplete output, and zero-result runs charge no `result-found`; the automatic Actor-start charge still applies.

Before paid delivery, the runtime verifies that the run budget can cover every selected row. It fails closed rather than partially writing a batch when capacity is insufficient or reporting paid success when named-event confirmation is uncertain.

### API and automation

Send the same JSON input to the Actor API. Keep the token out of shell history and source control; the literal below is only a placeholder:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/e6wV1MYbPGryoT5ZD/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  --data '{"companyUid":"FICTIONAL.001","companyToken":"REPLACE_WITH_YOUR_COMEET_TOKEN","titleContains":"","departmentContains":"","locationContains":"","remoteOnly":false,"maxResults":25}'
```

After the Run succeeds, read `defaultDatasetId` from its API object and fetch the rows:

```bash
curl "https://api.apify.com/v2/datasets/DEFAULT_DATASET_ID/items?clean=1&format=json&token=YOUR_APIFY_TOKEN"
```

In Console, public Task `TdlZaNmMI1avtxcOK` runs unchanged only as Comeet's public mock-data sandbox demo. For production, replace both its sandbox UID and sandbox token with credentials for a company feed you are authorized to process. In Make, Zapier, or n8n, start the Actor or your configured Task, wait for a terminal Run status, and pass the default Dataset URL downstream. Before retrying a client timeout, inspect the original Run and Dataset so a potentially paid delivery is not duplicated.

### Source rights and attribution

Comeet documents its Careers API for retrieving careers positions in its [Careers API overview](https://developers.comeet.com/reference/careers-api-overview), [position reference](https://developers.comeet.com/reference/retrieve-a-position-new), and [FAQ](https://developers.comeet.com/reference/faq). The overview explicitly publishes a mock-data sandbox UID and token, which this Actor uses only as the default demo input. For production, the Actor uses the company UID and Careers token supplied from the authorized company's Careers Website settings and retains only bounded published-job facts.

You must own or be authorized to process the configured company feed and remain responsible for Comeet's terms, the employer's terms, and downstream use. Source names and links provide attribution; they do not imply affiliation or grant rights to employer content. The Actor excludes descriptions and requirements prose, application-routing email, street and postal details, arrival instructions, picture and token-bearing URLs, candidate data, and application submission.

### Security and data handling

- The Actor runs with Apify `LIMITED_PERMISSIONS` and does not call another Actor or an AI service.
- `companyToken` is a masked secret input, accepted only in a closed 16–200-character URL-safe form. It is not returned in output or written to Actor logs.
- The request target is fixed to HTTPS on `www.comeet.co`; redirects are disabled and rejected.
- The response must be identity-encoded JSON with fatal UTF-8 decoding, a closed position/location shape, and bounded size.
- Source text is normalized, control characters are rejected, and spreadsheet-formula prefixes in retained strings are neutralized.
- Successful normalized rows are stored only in the run's default Dataset. The Actor does not create a history database, contact a company or candidate, or submit an application.

### Hard limits

| Limit | Value |
| --- | ---: |
| Company feeds per run | 1 |
| Source requests | 1 |
| Automatic retries | 0 |
| Followed redirects | 0 |
| Source request timeout | 12 seconds |
| Response body | 2,097,152 bytes |
| Source positions | 1,000 |
| Delivered rows | 0–100 |
| Bytes per row / selected batch | 16,384 / 1,900,000 |
| Filter length | 100 characters each |
| Actor memory / hard timeout | 128 MB / 60 seconds |

The Actor reads only one source response and does not paginate. More than 1,000 positions, an unexpected source field, a duplicate position ID, an invalid public page URL, or another source-interface change fails the complete run instead of silently dropping unvalidated data.

### Limits and sample scope

Results describe one authorized company's source response at one run time, after the configured filters and `maxResults` cap. They are not a complete Comeet employer index, a total-market demand estimate, an availability guarantee, or historical data. Source-provided facts can be stale or incomplete, and an empty field has only the meaning defined by the source.

The public Task is a safe configuration example backed by Comeet's public mock-data credential, not a production credential or a continuously refreshed dataset. Replace both sandbox identifiers and judge downstream fitness against your own authorized feed before production use.

### Troubleshooting

**Why did the run report `input_invalid`?**

Confirm that `companyUid` and `companyToken` are present, the token has no surrounding whitespace, optional filters are at most 100 characters, `maxResults` is 1–100, and the input has no unknown fields.

**Why did the run report `source_status_invalid` or `source_shape_invalid`?**

The credential/source response was not compatible with the bounded contract, or Comeet's interface changed. Check the company UID and token against Careers Website settings. The Actor withholds the complete output rather than guessing.

**Why did the run report `source_too_large`?**

The declared or streamed response exceeded 2 MiB. Narrowing `maxResults` does not reduce the source response, so the Actor cannot safely process that feed under its current bound.

**Why did the run report `budget_insufficient`?**

Increase `maxTotalChargeUsd` enough for the start event plus every selected row, or lower `maxResults`. No paid Dataset row is started for that rejected delivery.

**Why did the run report `billing_confirmation_failed`?**

The named `result-found` count did not confirm the Dataset write. Inspect the Run and Dataset before retrying; the Actor deliberately does not delete or repeat a potentially paid write.

### FAQ

**Does this find every company using Comeet?** No. It reads exactly one company UID and token you supply.

**Does it return descriptions or requirements?** No. The request uses `details=false`, and prose, email, address, picture, and token-bearing URL fields are excluded.

**Can it apply to a job or process candidates?** No. Public page URLs are output values only; the Actor performs no application or candidate action.

**Can I use the public Task without editing it?** Yes, for the public Comeet mock-data demo only. Replace its sandbox UID and token with credentials you are authorized to use before processing a production company feed.

**Can I monitor changes?** Yes, downstream: retain successive Datasets and compare `jobId` plus `changeFingerprint`. The Actor itself stores no snapshot history.

**Are zero results billed?** No `result-found` event is charged for zero rows, but the automatic Actor-start event still applies.

# Actor input Schema

## `companyUid` (type: `string`):

Public mock prefill: Comeet's documented sandbox UID E5.007. Replace it with the company UID from Careers Website settings for production use.

## `companyToken` (type: `string`):

Public mock prefill: Comeet's documented sandbox token. Replace it with the buyer-authorized Careers token for production use; it is used only for the one fixed official API request.

## `titleContains` (type: `string`):

Optional case-insensitive title substring.

## `departmentContains` (type: `string`):

Optional case-insensitive department substring.

## `locationContains` (type: `string`):

Optional case-insensitive match across the public location name, city, state, country code and timezone.

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

Keep positions marked remote by the source location or workplace type.

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

Maximum factual Dataset rows retained after deterministic filtering and sorting.

## Actor input object example

```json
{
  "companyUid": "E5.007",
  "companyToken": "5E7236A0BCE5E7295111B55E70BCE",
  "titleContains": "",
  "departmentContains": "",
  "locationContains": "",
  "remoteOnly": false,
  "maxResults": 100
}
```

# Actor output Schema

## `jobs` (type: `string`):

API URL for token-free factual rows. Descriptions, application email, street/postal details, pictures, token-bearing URLs and candidate data are excluded.

# 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 = {
    "companyUid": "E5.007",
    "companyToken": "5E7236A0BCE5E7295111B55E70BCE"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/comeet-careers-jobs-api").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 = {
    "companyUid": "E5.007",
    "companyToken": "5E7236A0BCE5E7295111B55E70BCE",
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/comeet-careers-jobs-api").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 '{
  "companyUid": "E5.007",
  "companyToken": "5E7236A0BCE5E7295111B55E70BCE"
}' |
apify call zinin/comeet-careers-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zinin/comeet-careers-jobs-api"
        }
    }
}

```

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/e6wV1MYbPGryoT5ZD/builds/ZTdb1iezQgsLYnRFD/openapi.json