# Job Posts to B2B Buying Signals (`signalflow_studio/job-posts-to-buying-signals`) Actor

Run selected upstream job Actors or process existing job data, then turn job posts into evidence-backed B2B buying-signal accounts with cost caps, scores, personas, and outreach angles.

- **URL**: https://apify.com/signalflow\_studio/job-posts-to-buying-signals.md
- **Developed by:** [SignalFlow Studio](https://apify.com/signalflow_studio) (community)
- **Categories:** Lead generation, Jobs, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 qualified accounts

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Job Posts to B2B Buying Signals

Turn job scraper outputs into evidence-backed B2B account signals.

This Actor is a sales-intelligence layer for job data. It accepts uploaded job rows, an existing Apify dataset, or one or more user-selected upstream job scraper Actors, then returns qualified companies whose hiring activity suggests an active buying need. Each result includes matched evidence, a signal score, inferred need, why-now context, recommended persona, and outreach angle.

It is not a LinkedIn scraper, Indeed scraper, or email finder. By default, it calls selected upstream job Actors using the Apify runtime token of the user who starts the run, then aggregates the returned job posts into account-level buying signals.

### Who it is for

- CRM, RevOps, Salesforce, and HubSpot implementation agencies.
- Data, BI, AI, analytics, and cloud consulting teams.
- Cybersecurity, compliance, SOC, GRC, and SIEM service providers.
- Outbound agencies turning job-post datasets into weekly account lists.
- B2B sales teams that want account-level signals instead of raw job rows.

### Source modes

#### Upstream Actor

This is the default mode. Adjust `jobSearchKeyword` and `jobSearchLocation`, optionally enable more source presets, then start the run. No manual API token input is needed on Apify because the platform provides the run token for the user who starts the Actor.

Run mechanism:

- This Actor calls each selected upstream Actor through Apify's `run-sync-get-dataset-items` API.
- The upstream Actor receives the source-specific `upstreamInput` and returns its dataset items to this Actor.
- Apify sets `APIFY_TOKEN` to the API token of the user who started the run, so upstream runs are started as that user, not as this Actor's owner.
- Each enabled simple source or enabled `upstreamActors` item can start one upstream Actor run.
- If an upstream Actor is paid, unavailable, private, or requires rental/access, that upstream run can fail or create a separate charge according to the upstream Actor's own Pricing tab.
- This Actor passes both `maxTotalChargeUsd` and `maxItems` to upstream runs. `maxTotalChargeUsd` caps the upstream run charge; `maxItems` limits charged result count for pay-per-result upstream Actors when supported by Apify.

Official Apify references:

- Runtime token: https://docs.apify.com/platform/actors/development/programming-interface/environment-variables
- Synchronous Actor run API: https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post
- Store pricing models: https://docs.apify.com/platform/actors/running/actors-in-store
- Pay-per-event pricing: https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event

Default simple inputs:

| Field | Default |
|---|---|
| `jobSearchKeyword` | `RevOps Manager` |
| `jobSearchLocation` | `United States` |
| `maxJobsPerSource` | `50`; mapped per source as LinkedIn `count`, Indeed `maxRows`, and ATS API `limit` |
| `maxUpstreamChargeUsdPerSource` | `1.00` |
| `useLinkedInJobs` | `true`; [curious_coder/linkedin-jobs-scraper](https://apify.com/curious_coder/linkedin-jobs-scraper), price snapshot: `$1.00 / 1,000 results` |
| `useIndeedJobs` | `false`; [borderline/indeed-scraper](https://apify.com/borderline/indeed-scraper), price snapshot: `$5.00 / 1,000 jobs` |
| `useGreenhouseJobs` | `false`; [fantastic-jobs/greenhouse-jobs-api](https://apify.com/fantastic-jobs/greenhouse-jobs-api), price snapshot: `from $1.20 / 1,000 jobs` |
| `useLeverJobs` | `false`; [fantastic-jobs/lever-co-jobs-api](https://apify.com/fantastic-jobs/lever-co-jobs-api), price snapshot: `from $0.80 / 1,000 jobs` |
| `useAshbyJobs` | `false`; [fantastic-jobs/ashby-jobs-api](https://apify.com/fantastic-jobs/ashby-jobs-api), price snapshot: `from $1.20 / 1,000 jobs` |

Use `upstreamActors` only when you need custom Actor IDs or source-specific JSON inputs.

#### Uploaded job rows

Paste or upload job rows directly when you already have job data.

#### Existing Apify dataset

Process a dataset produced by another Actor. Private datasets are read with the run user's Apify token.

Default presets and upstream price snapshot:

Snapshot checked on 2026-05-27. Upstream authors can change pricing; the upstream Actor's Pricing tab is authoritative at run time.

| Preset | Actor | Store link | Upstream price snapshot |
|---|---|---|---|
| `linkedin_jobs_popular` | `curious_coder/linkedin-jobs-scraper` | https://apify.com/curious_coder/linkedin-jobs-scraper | `$1.00 / 1,000 results` |
| `indeed_jobs_popular` | `borderline/indeed-scraper` | https://apify.com/borderline/indeed-scraper | `$5.00 / 1,000 jobs` |
| `greenhouse_jobs_api` | `fantastic-jobs/greenhouse-jobs-api` | https://apify.com/fantastic-jobs/greenhouse-jobs-api | `from $1.20 / 1,000 jobs` |
| `lever_jobs_api` | `fantastic-jobs/lever-co-jobs-api` | https://apify.com/fantastic-jobs/lever-co-jobs-api | `from $0.80 / 1,000 jobs` |
| `ashby_jobs_api` | `fantastic-jobs/ashby-jobs-api` | https://apify.com/fantastic-jobs/ashby-jobs-api | `from $1.20 / 1,000 jobs` |
| `custom` | Any public or accessible Actor ID | Check the custom Actor page | Check the custom Actor Pricing tab |

Simple mode maps the keyword/location fields to each upstream Actor's current input schema:

| Source | Simple input sent upstream |
|---|---|
| LinkedIn | `urls=[generated LinkedIn jobs search URL]`, `count=max(maxJobsPerSource, 10)`, `scrapeCompany=true` |
| Indeed | `query=jobSearchKeyword`, `location=jobSearchLocation`, `maxRows=maxJobsPerSource` |
| Greenhouse / Lever / Ashby | `titleSearch=[jobSearchKeyword]`, `locationSearch=[jobSearchLocation]`, `limit=max(maxJobsPerSource, 200)`, `includeAi=false`, `includeLinkedIn=true` |

Upstream Actor fees are separate and charged by each selected upstream Actor to the user who starts the run.

### Quick start

Default run:

```json
{
  "jobSearchKeyword": "RevOps Manager",
  "jobSearchLocation": "United States",
  "maxJobsPerSource": 50,
  "maxUpstreamChargeUsdPerSource": 1,
  "playbook": "crm_revops",
  "jobKeywords": ["RevOps Manager", "Revenue Operations", "HubSpot"],
  "enableAiInsights": false,
  "minSignalScore": 60,
  "maxResults": 25
}
````

Advanced multi-Actor override:

```json
{
  "sourceMode": "upstream_actor",
  "upstreamActors": [
    {
      "enabled": true,
      "label": "LinkedIn RevOps search",
      "upstreamPreset": "linkedin_jobs_popular",
      "upstreamInput": {
        "urls": ["https://www.linkedin.com/jobs/search/?keywords=RevOps+Manager&location=United+States"],
        "count": 100,
        "scrapeCompany": true
      }
    },
    {
      "enabled": true,
      "label": "Indeed Salesforce search",
      "upstreamPreset": "indeed_jobs_popular",
      "upstreamInput": {
        "query": "Salesforce Administrator",
        "location": "United States",
        "maxRows": 100
      }
    }
  ],
  "playbook": "crm_revops",
  "jobKeywords": ["RevOps Manager", "Salesforce Administrator", "HubSpot"],
  "maxJobsToProcess": 100,
  "maxResults": 25
}
```

### Inputs

| Field | Description |
|---|---|
| `sourceMode` | Defaults to `upstream_actor`; can also be `uploaded_job_rows` or `dataset`. |
| `jobSearchKeyword` | Main role, skill, or tool keyword for the default upstream job search. |
| `jobSearchLocation` | Location passed to upstream job sources that support location search. |
| `maxJobsPerSource` | Limit passed to each simple upstream source using that Actor's expected field. LinkedIn has minimum `count=10`; Greenhouse/Lever/Ashby have minimum `limit=200`. |
| `maxUpstreamChargeUsdPerSource` | Maximum charge passed to each upstream Actor run as Apify `maxTotalChargeUsd`. Default USD 1.00 per enabled upstream source. |
| `useLinkedInJobs`, `useIndeedJobs`, `useGreenhouseJobs`, `useLeverJobs`, `useAshbyJobs` | Simple source toggles for non-technical users. |
| `upstreamActors` | Advanced override array for multiple custom upstream Actor configs. Leave empty to use the simple toggles. |
| `simulateUpstreamRun` | Uses mock items instead of calling upstream Actors. Useful for testing. |
| `sourceDatasetId` | Existing Apify dataset ID to process. |
| `jobRows` | Uploaded job rows. |
| `playbook` | `crm_revops`, `data_stack`, `cybersecurity`, or `custom`. |
| `jobKeywords` | Extra job title, skill, or tool keywords to match. |
| `locations` | Optional location keyword filters. |
| `postedWithinDays` | Preferred recency window for jobs with dates. |
| `minSignalScore` | Minimum score required for dataset output. |
| `maxJobsToProcess` | Default 100, hard cap 10000. |
| `maxResults` | Default 25, hard cap 500. |
| `enableAiInsights` | BYOK AI-assisted insight generation; deterministic text is used without a key. |
| `aiProviderApiKey` | Optional secret BYOK key for AI-assisted insight generation. |

### Output

The default dataset contains one row per qualified account:

```json
{
  "companyName": "Instrumentl",
  "domain": "instrumentl.com",
  "playbook": "crm_revops",
  "signalScore": 78,
  "signalTier": "medium",
  "inferredNeed": "Likely scaling CRM, sales operations, or revenue operations workflows",
  "whyNow": "The company shows 1 matching hiring signal(s), including RevOps Manager.",
  "recommendedPersona": "VP Sales, RevOps Lead, COO, Head of Sales Operations",
  "outreachAngle": "Lead with CRM implementation cleanup, reporting automation, pipeline process design, and RevOps capacity support.",
  "matchedKeywords": ["hubspot", "revops", "revops manager"],
  "openRolesCount": 1,
  "evidence": [
    {
      "source": "lever_public_job",
      "jobTitle": "RevOps Manager",
      "postedAt": "2026-05-20",
      "url": "https://jobs.lever.co/Instrumentl/a2c6c454-00a1-4ab0-9c02-cddfffec17b5"
    }
  ],
  "status": "qualified"
}
```

The key-value store also includes:

- `OUTPUT`: complete JSON output with summary and results.
- `REPORT`: a Markdown report for human review.

### Pricing and cost model

Suggested pay-per-event model:

- `apify-actor-start`: small automatic start fee.
- `source_dataset_processed`: charged when a source dataset is processed.
- `upstream_actor_called`: charged once per upstream Actor successfully triggered.
- `job_normalized`: charged per normalized job row processed.
- `qualified_account`: charged per evidence-backed qualified account.
- `ai_insight`: charged when BYOK AI insight generation succeeds.

There are two cost layers:

1. This Actor's PPE events:
   - `apify-actor-start`: charged automatically by Apify when the run starts.
   - `upstream_actor_called`: charged once after this Actor successfully triggers an upstream Actor.
   - `job_normalized`: charged per normalized job row analyzed by this Actor.
   - `qualified_account`: charged per evidence-backed account emitted.
   - `ai_insight`: charged only when BYOK AI generation succeeds.

2. Upstream Actor charges:
   - Each selected upstream Actor has its own pricing model and may charge separately.
   - This Actor passes `maxUpstreamChargeUsdPerSource` as `maxTotalChargeUsd` to each upstream run.
   - This Actor also passes Apify `maxItems` to each upstream run to cap charged result count for PPR Actors when supported.
   - The default is USD 1.00 per enabled upstream source.
   - `maxJobsPerSource` is mapped to each upstream Actor's documented input field, but upstream Actors may still interpret limits differently.

Apify Store notes that PPE Actors charge for creator-defined events and that some Actors include platform usage in event prices while others charge it separately. Always check each upstream Actor's Pricing tab before enabling it.

AI provider costs are BYOK by default. If `aiProviderApiKey` is empty, this Actor does not call an external AI provider and uses deterministic insight text.

### Limits

Default public run:

- runs the LinkedIn Jobs preset with `RevOps Manager` and `United States`,
- requests up to 50 jobs from the default LinkedIn source,
- caps each upstream Actor run at USD 1.00 through Apify `maxTotalChargeUsd`,
- processes up to 100 normalized job rows,
- emits up to 25 qualified accounts.

Hard caps:

- `maxJobsToProcess`: 10000
- `maxResults`: 500

### Compliance and acceptable use

Use only data you are allowed to process. Respect source website terms, upstream Actor terms, privacy laws, and outreach rules in your jurisdiction. Do not use output for spam, harassment, discriminatory targeting, or unlawful profiling.

### Known limits

- Upstream Actor input schemas and output fields can change; review every selected upstream Actor before production runs.
- Default run timeout is 300 seconds. The default one-source run is designed for this; if you enable several real upstream sources, increase the run timeout in Apify run options.
- Company domain extraction depends on source data quality.
- This Actor does not guarantee personal contact data or verified emails.
- AI insight text summarizes visible evidence and should be reviewed before use.

### Local development

```bash
npm install
npm run sample
npm run smoke
npm run mock-upstream
npm test
```

`npm run mock-upstream` validates multiple upstream Actor adapters using simulated upstream dataset items. It does not call any upstream Actor.

### Apify deployment

This Actor is intended to be prepared privately first. Do not publish automatically.

```bash
npx apify-cli@1.6.1 push --version 0.1 --build-tag latest
npx apify-cli@1.6.1 call signalflow_studio/job-posts-to-buying-signals --input-file fixtures/cloud-smoke-input.json --memory 1024 --timeout 180 --json
```

# Actor input Schema

## `sourceMode` (type: `string`):

Default: run upstream job Actor(s), then convert the job posts into qualified account signals. Use uploaded rows or dataset mode only when you already have job data.

## `jobSearchKeyword` (type: `string`):

Main role, skill, or tool keyword to search for in upstream job sources.

## `jobSearchLocation` (type: `string`):

Location passed to upstream job sources that support location search.

## `maxJobsPerSource` (type: `integer`):

Limit passed to each simple upstream Actor using that Actor's expected input field: LinkedIn count, Indeed maxRows, ATS APIs limit. LinkedIn has a minimum count of 10; Greenhouse/Lever/Ashby APIs have a minimum limit of 200, so values below those minimums are raised for that source. Check each upstream Actor's Input and Pricing tabs.

## `maxUpstreamChargeUsdPerSource` (type: `number`):

Maximum Apify charge allowed for each upstream Actor run, passed as maxTotalChargeUsd to Apify's run-sync-get-dataset-items API. This Actor also passes maxItems to cap paid result count for PPR upstream Actors when supported. Default USD 1.00 per enabled upstream source. Increase only after checking the upstream Actor's Pricing tab. Official run limit docs: https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post

## `useLinkedInJobs` (type: `boolean`):

Upstream Actor: https://apify.com/curious\_coder/linkedin-jobs-scraper. Price snapshot checked 2026-05-27: $1.00 / 1,000 results. Simple mode sends urls=\[generated LinkedIn job search URL], count=maxJobsPerSource minimum 10, scrapeCompany=true. Check the Actor's Pricing tab before running.

## `useIndeedJobs` (type: `boolean`):

Upstream Actor: https://apify.com/borderline/indeed-scraper. Price snapshot checked 2026-05-27: $5.00 / 1,000 jobs. Simple mode sends query, location, and maxRows=maxJobsPerSource. Enabling more sources increases possible upstream charges and this Actor's upstream\_actor\_called/job\_normalized events.

## `useGreenhouseJobs` (type: `boolean`):

Upstream Actor: https://apify.com/fantastic-jobs/greenhouse-jobs-api. Price snapshot checked 2026-05-27: from $1.20 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.

## `useLeverJobs` (type: `boolean`):

Upstream Actor: https://apify.com/fantastic-jobs/lever-co-jobs-api. Price snapshot checked 2026-05-27: from $0.80 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.

## `useAshbyJobs` (type: `boolean`):

Upstream Actor: https://apify.com/fantastic-jobs/ashby-jobs-api. Price snapshot checked 2026-05-27: from $1.20 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.

## `upstreamActors` (type: `array`):

Optional advanced override. Leave empty to use the simple source toggles above. Add multiple items here when you need custom Actor IDs or source-specific inputs. Built-in preset price snapshots checked 2026-05-27: linkedin\_jobs\_popular $1.00/1K results, indeed\_jobs\_popular $5.00/1K jobs, greenhouse\_jobs\_api from $1.20/1K jobs, lever\_jobs\_api from $0.80/1K jobs, ashby\_jobs\_api from $1.20/1K jobs. Each enabled item may start one upstream Actor run and can create separate upstream Actor charges for the run user.

## `simulateUpstreamRun` (type: `boolean`):

Use mockUpstreamItems from each upstreamActors item instead of calling upstream Actors. Intended for testing adapters without generating upstream Actor charges. Leave false for normal use.

## `sourceDatasetId` (type: `string`):

Existing Apify dataset ID to process when sourceMode is dataset.

## `jobRows` (type: `array`):

Direct job rows to process. Supports common fields such as companyName, company, domain, jobTitle, title, description, url, jobUrl, location, postedAt, and source.

## `playbook` (type: `string`):

The buying-need pattern to detect from job posts.

## `jobKeywords` (type: `array`):

Custom job title, skill, and tool keywords. These supplement the selected playbook.

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

Optional location keywords. Leave empty to match all locations.

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

Prefer jobs posted within this many days. Rows without postedAt are still considered with lower recency confidence.

## `minSignalScore` (type: `integer`):

Only accounts at or above this score are emitted to the main dataset.

## `maxJobsToProcess` (type: `integer`):

Maximum normalized job rows this Actor analyzes after upstream data is returned. This controls this Actor's job\_normalized PPE events, but does not replace upstream Actor pricing limits.

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

Maximum qualified accounts to output. This controls this Actor's qualified\_account PPE events.

## `excludeStaffingAgencies` (type: `boolean`):

Penalize likely recruiters, staffing firms, and job boards so output focuses on buying accounts.

## `enableAiInsights` (type: `boolean`):

Generate concise inferred need, why-now, recommended persona, and outreach angle for qualified accounts. AI is BYOK only: if no AI key is supplied, deterministic insight text is used and no external AI provider is called.

## `aiProvider` (type: `string`):

AI provider used when an API key is supplied.

## `aiProviderApiKey` (type: `string`):

Optional BYOK key for AI-assisted insight generation. Leave empty to use deterministic insights without external AI calls.

## `aiModel` (type: `string`):

Optional model override. Defaults: deepseek-chat, openai/gpt-4.1-mini on OpenRouter, or gpt-4.1-mini on OpenAI.

## `maxAiInsights` (type: `integer`):

Maximum qualified accounts that receive AI-assisted insights.

## `debug` (type: `boolean`):

Include more progress details in logs and OUTPUT.

## Actor input object example

```json
{
  "sourceMode": "upstream_actor",
  "jobSearchKeyword": "RevOps Manager",
  "jobSearchLocation": "United States",
  "maxJobsPerSource": 50,
  "maxUpstreamChargeUsdPerSource": 1,
  "useLinkedInJobs": true,
  "useIndeedJobs": false,
  "useGreenhouseJobs": false,
  "useLeverJobs": false,
  "useAshbyJobs": false,
  "upstreamActors": [],
  "simulateUpstreamRun": false,
  "jobRows": [
    {
      "companyName": "Instrumentl",
      "domain": "instrumentl.com",
      "jobTitle": "RevOps Manager",
      "description": "Own HubSpot, lead scoring, reporting, segmentation, product usage data, enrichment providers, and GTM systems.",
      "postedAt": "2026-05-20",
      "url": "https://jobs.lever.co/Instrumentl/a2c6c454-00a1-4ab0-9c02-cddfffec17b5",
      "source": "lever_public_job"
    }
  ],
  "playbook": "crm_revops",
  "jobKeywords": [
    "RevOps Manager",
    "Salesforce Administrator",
    "HubSpot"
  ],
  "postedWithinDays": 30,
  "minSignalScore": 70,
  "maxJobsToProcess": 100,
  "maxResults": 25,
  "excludeStaffingAgencies": true,
  "enableAiInsights": false,
  "aiProvider": "deepseek",
  "maxAiInsights": 100,
  "debug": false
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Structured JSON dataset with one item per qualified account.

## `jsonOutput` (type: `string`):

Full structured output stored in the default key-value store.

## `markdownReport` (type: `string`):

Human-readable Markdown report stored in the default key-value store.

# 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 = {
    "jobSearchKeyword": "RevOps Manager",
    "jobSearchLocation": "United States",
    "upstreamActors": [],
    "jobRows": [
        {
            "companyName": "Instrumentl",
            "domain": "instrumentl.com",
            "jobTitle": "RevOps Manager",
            "description": "Own HubSpot, lead scoring, reporting, segmentation, product usage data, enrichment providers, and GTM systems.",
            "postedAt": "2026-05-20",
            "url": "https://jobs.lever.co/Instrumentl/a2c6c454-00a1-4ab0-9c02-cddfffec17b5",
            "source": "lever_public_job"
        }
    ],
    "jobKeywords": [
        "RevOps Manager",
        "Salesforce Administrator",
        "HubSpot"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalflow_studio/job-posts-to-buying-signals").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 = {
    "jobSearchKeyword": "RevOps Manager",
    "jobSearchLocation": "United States",
    "upstreamActors": [],
    "jobRows": [{
            "companyName": "Instrumentl",
            "domain": "instrumentl.com",
            "jobTitle": "RevOps Manager",
            "description": "Own HubSpot, lead scoring, reporting, segmentation, product usage data, enrichment providers, and GTM systems.",
            "postedAt": "2026-05-20",
            "url": "https://jobs.lever.co/Instrumentl/a2c6c454-00a1-4ab0-9c02-cddfffec17b5",
            "source": "lever_public_job",
        }],
    "jobKeywords": [
        "RevOps Manager",
        "Salesforce Administrator",
        "HubSpot",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("signalflow_studio/job-posts-to-buying-signals").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "jobSearchKeyword": "RevOps Manager",
  "jobSearchLocation": "United States",
  "upstreamActors": [],
  "jobRows": [
    {
      "companyName": "Instrumentl",
      "domain": "instrumentl.com",
      "jobTitle": "RevOps Manager",
      "description": "Own HubSpot, lead scoring, reporting, segmentation, product usage data, enrichment providers, and GTM systems.",
      "postedAt": "2026-05-20",
      "url": "https://jobs.lever.co/Instrumentl/a2c6c454-00a1-4ab0-9c02-cddfffec17b5",
      "source": "lever_public_job"
    }
  ],
  "jobKeywords": [
    "RevOps Manager",
    "Salesforce Administrator",
    "HubSpot"
  ]
}' |
apify call signalflow_studio/job-posts-to-buying-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=signalflow_studio/job-posts-to-buying-signals",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Posts to B2B Buying Signals",
        "description": "Run selected upstream job Actors or process existing job data, then turn job posts into evidence-backed B2B buying-signal accounts with cost caps, scores, personas, and outreach angles.",
        "version": "0.1",
        "x-build-id": "kDRNRulKrBy6NagsN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/signalflow_studio~job-posts-to-buying-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-signalflow_studio-job-posts-to-buying-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/signalflow_studio~job-posts-to-buying-signals/runs": {
            "post": {
                "operationId": "runs-sync-signalflow_studio-job-posts-to-buying-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/signalflow_studio~job-posts-to-buying-signals/run-sync": {
            "post": {
                "operationId": "run-sync-signalflow_studio-job-posts-to-buying-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sourceMode": {
                        "title": "Source mode",
                        "enum": [
                            "uploaded_job_rows",
                            "dataset",
                            "upstream_actor"
                        ],
                        "type": "string",
                        "description": "Default: run upstream job Actor(s), then convert the job posts into qualified account signals. Use uploaded rows or dataset mode only when you already have job data.",
                        "default": "upstream_actor"
                    },
                    "jobSearchKeyword": {
                        "title": "Job search keyword",
                        "type": "string",
                        "description": "Main role, skill, or tool keyword to search for in upstream job sources.",
                        "default": "RevOps Manager"
                    },
                    "jobSearchLocation": {
                        "title": "Job search location",
                        "type": "string",
                        "description": "Location passed to upstream job sources that support location search.",
                        "default": "United States"
                    },
                    "maxJobsPerSource": {
                        "title": "Max jobs per source",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Limit passed to each simple upstream Actor using that Actor's expected input field: LinkedIn count, Indeed maxRows, ATS APIs limit. LinkedIn has a minimum count of 10; Greenhouse/Lever/Ashby APIs have a minimum limit of 200, so values below those minimums are raised for that source. Check each upstream Actor's Input and Pricing tabs.",
                        "default": 50
                    },
                    "maxUpstreamChargeUsdPerSource": {
                        "title": "Max upstream charge per source",
                        "minimum": 0.1,
                        "maximum": 100,
                        "type": "number",
                        "description": "Maximum Apify charge allowed for each upstream Actor run, passed as maxTotalChargeUsd to Apify's run-sync-get-dataset-items API. This Actor also passes maxItems to cap paid result count for PPR upstream Actors when supported. Default USD 1.00 per enabled upstream source. Increase only after checking the upstream Actor's Pricing tab. Official run limit docs: https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post",
                        "default": 1
                    },
                    "useLinkedInJobs": {
                        "title": "Use LinkedIn Jobs - $1.00 / 1K results",
                        "type": "boolean",
                        "description": "Upstream Actor: https://apify.com/curious_coder/linkedin-jobs-scraper. Price snapshot checked 2026-05-27: $1.00 / 1,000 results. Simple mode sends urls=[generated LinkedIn job search URL], count=maxJobsPerSource minimum 10, scrapeCompany=true. Check the Actor's Pricing tab before running.",
                        "default": true
                    },
                    "useIndeedJobs": {
                        "title": "Use Indeed Jobs - $5.00 / 1K jobs",
                        "type": "boolean",
                        "description": "Upstream Actor: https://apify.com/borderline/indeed-scraper. Price snapshot checked 2026-05-27: $5.00 / 1,000 jobs. Simple mode sends query, location, and maxRows=maxJobsPerSource. Enabling more sources increases possible upstream charges and this Actor's upstream_actor_called/job_normalized events.",
                        "default": false
                    },
                    "useGreenhouseJobs": {
                        "title": "Use Greenhouse Jobs API - from $1.20 / 1K jobs",
                        "type": "boolean",
                        "description": "Upstream Actor: https://apify.com/fantastic-jobs/greenhouse-jobs-api. Price snapshot checked 2026-05-27: from $1.20 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.",
                        "default": false
                    },
                    "useLeverJobs": {
                        "title": "Use Lever Jobs API - from $0.80 / 1K jobs",
                        "type": "boolean",
                        "description": "Upstream Actor: https://apify.com/fantastic-jobs/lever-co-jobs-api. Price snapshot checked 2026-05-27: from $0.80 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.",
                        "default": false
                    },
                    "useAshbyJobs": {
                        "title": "Use Ashby Jobs API - from $1.20 / 1K jobs",
                        "type": "boolean",
                        "description": "Upstream Actor: https://apify.com/fantastic-jobs/ashby-jobs-api. Price snapshot checked 2026-05-27: from $1.20 / 1,000 jobs. Simple mode sends titleSearch, locationSearch, limit=maxJobsPerSource minimum 200, includeAi=false, includeLinkedIn=true.",
                        "default": false
                    },
                    "upstreamActors": {
                        "title": "Advanced upstream Actors",
                        "type": "array",
                        "description": "Optional advanced override. Leave empty to use the simple source toggles above. Add multiple items here when you need custom Actor IDs or source-specific inputs. Built-in preset price snapshots checked 2026-05-27: linkedin_jobs_popular $1.00/1K results, indeed_jobs_popular $5.00/1K jobs, greenhouse_jobs_api from $1.20/1K jobs, lever_jobs_api from $0.80/1K jobs, ashby_jobs_api from $1.20/1K jobs. Each enabled item may start one upstream Actor run and can create separate upstream Actor charges for the run user."
                    },
                    "simulateUpstreamRun": {
                        "title": "Simulate upstream run",
                        "type": "boolean",
                        "description": "Use mockUpstreamItems from each upstreamActors item instead of calling upstream Actors. Intended for testing adapters without generating upstream Actor charges. Leave false for normal use.",
                        "default": false
                    },
                    "sourceDatasetId": {
                        "title": "Source dataset ID",
                        "type": "string",
                        "description": "Existing Apify dataset ID to process when sourceMode is dataset."
                    },
                    "jobRows": {
                        "title": "Uploaded job rows",
                        "type": "array",
                        "description": "Direct job rows to process. Supports common fields such as companyName, company, domain, jobTitle, title, description, url, jobUrl, location, postedAt, and source."
                    },
                    "playbook": {
                        "title": "Intent playbook",
                        "enum": [
                            "crm_revops",
                            "data_stack",
                            "cybersecurity",
                            "custom"
                        ],
                        "type": "string",
                        "description": "The buying-need pattern to detect from job posts.",
                        "default": "crm_revops"
                    },
                    "jobKeywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "Custom job title, skill, and tool keywords. These supplement the selected playbook.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional location keywords. Leave empty to match all locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Prefer jobs posted within this many days. Rows without postedAt are still considered with lower recency confidence.",
                        "default": 30
                    },
                    "minSignalScore": {
                        "title": "Minimum signal score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only accounts at or above this score are emitted to the main dataset.",
                        "default": 70
                    },
                    "maxJobsToProcess": {
                        "title": "Max jobs to process",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum normalized job rows this Actor analyzes after upstream data is returned. This controls this Actor's job_normalized PPE events, but does not replace upstream Actor pricing limits.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max qualified accounts",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum qualified accounts to output. This controls this Actor's qualified_account PPE events.",
                        "default": 25
                    },
                    "excludeStaffingAgencies": {
                        "title": "Exclude staffing agencies",
                        "type": "boolean",
                        "description": "Penalize likely recruiters, staffing firms, and job boards so output focuses on buying accounts.",
                        "default": true
                    },
                    "enableAiInsights": {
                        "title": "Generate AI-assisted insights",
                        "type": "boolean",
                        "description": "Generate concise inferred need, why-now, recommended persona, and outreach angle for qualified accounts. AI is BYOK only: if no AI key is supplied, deterministic insight text is used and no external AI provider is called.",
                        "default": false
                    },
                    "aiProvider": {
                        "title": "AI provider",
                        "enum": [
                            "deepseek",
                            "openrouter",
                            "openai"
                        ],
                        "type": "string",
                        "description": "AI provider used when an API key is supplied.",
                        "default": "deepseek"
                    },
                    "aiProviderApiKey": {
                        "title": "AI provider API key",
                        "type": "string",
                        "description": "Optional BYOK key for AI-assisted insight generation. Leave empty to use deterministic insights without external AI calls."
                    },
                    "aiModel": {
                        "title": "AI model",
                        "type": "string",
                        "description": "Optional model override. Defaults: deepseek-chat, openai/gpt-4.1-mini on OpenRouter, or gpt-4.1-mini on OpenAI."
                    },
                    "maxAiInsights": {
                        "title": "Max AI insights",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum qualified accounts that receive AI-assisted insights.",
                        "default": 100
                    },
                    "debug": {
                        "title": "Debug logs",
                        "type": "boolean",
                        "description": "Include more progress details in logs and OUTPUT.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
