# LinkedIn Hiring Signals — Company Hiring Intent & Velocity (`foxlabs/linkedin-hiring-signals`) Actor Track which companies are hiring & how fast. Input companies → open-role count, hiring velocity (posted last 7/30/90 days), momentum, department & location breakdown, full job list + employer firmographics (size, industry, HQ, domain). Sales-intent, no login. - **URL**: https://apify.com/foxlabs/linkedin-hiring-signals.md - **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community) - **Categories:** Lead generation, Jobs - **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $30.00 / 1,000 results 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 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

LinkedIn Hiring Signals — Company Hiring Intent & Velocity

## LinkedIn Hiring Signals — Company Hiring Intent & Velocity Point this Actor at a list of companies and learn **who is hiring, for what, and how fast** — a company-qualified **sales-intent** feed built from **public** LinkedIn job postings (no login, no cookies). Rivals hand you a flat job search; this resolves the **employer entity**, computes **hiring velocity**, and fuses the company's **firmographics** into one clean record — every field provenance-tagged. - 🎯 **Company-centric, not a job dump** — one record per company: open-role count, momentum, and the full role breakdown. - 📈 **Velocity, not a snapshot** — 7 / 30 / 90-day posting deltas show who's *accelerating* hiring, the strongest growth/buying signal. - 🏢 **Firmographics fused inline** — employee count, industry, HQ, domain & followers, so "who's hiring" becomes "**500-person fintechs that added 12 sales roles this month**". - 🔗 **Entity-resolved & joinable** — each company resolved to its LinkedIn id + **domain**, so records join cleanly to your CRM. No login, no cookies. ### Quick start (API) Track three companies and get their hiring-signal records in one call: ```bash curl -X POST "https://api.apify.com/v2/acts/foxlabs~linkedin-hiring-signals/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "companies": ["stripe", "datadog", "https://www.linkedin.com/company/openai/"], "maxJobsPerCompany": 200 }' ``` Prefer no code? Open the **Input** tab, paste your companies (URLs or slugs), and click **Start** — then download the results. ### What you get One clean, flat record per company: | Field | Type | Description | |---|---|---| | `companyName` | string | Company name (from the LinkedIn page; falls back to the slug) | | `companySlug` | string | LinkedIn company handle from `/company/{slug}` | | `companyLinkedInUrl` | string | Canonical company page URL | | `companyId` | string | null | Numeric LinkedIn organization id (`urn:li:organization:…`) | | `companyDomain` | string | null | Company website domain — the clean **join key** for CRM / enrichment | | `employeeCount` | number | null | Employee count (firmographic) | | `industry` | string | null | Industry (firmographic) | | `hq` | string | null | Headquarters — city, region, country | | `followers` | number | null | LinkedIn follower count | | `website` | string | null | Company website URL | | `founded` | number | null | Founding year, read from the company's public **About** block (`null` when LinkedIn doesn't show one) | | `ownership` | object | Ultimate beneficial owner (KYB), resolved from GLEIF + Companies House PSC: `{ registeredEntity, companyNumber, jurisdiction, ultimateBeneficialOwner, ultimateOwnerType, ultimateOwnerCountry, crossBorderOwnership, ownershipChain, ownershipConfidence, ownershipSource }`. Present only above the confidence gate — never guessed | | `hiringSignalsCollected` | boolean | `false` when the company id couldn't be resolved — the job feed was never queried, so **no** hiring field below is present (an absence of measurement, not "not hiring") | | `openJobCount` | number | Open public roles found (up to `maxJobsPerCompany`) | | `isHiring` | boolean | `true` when any open role was found | | `hiringMomentum` | string | `high` / `medium` / `low` / `not-hiring`, or **`unknown (capped)`** when the cap truncated the sample (thresholds & rule in FAQ) | | `momentumMeasurable` | boolean | `false` when the cap makes momentum unknowable — don't score on `hiringMomentum` in that case | | `postedLast7d` / `postedLast30d` / `postedLast90d` | number | Roles posted within the last 7 / 30 / 90 days (velocity) | | `newestJobDate` / `oldestJobDate` | string | null | Date range of the sampled postings (`YYYY-MM-DD`) | | `topDepartments` | array | `[{ name, count }]` — department mix **inferred from job titles** | | `topLocations` | array | `[{ name, count }]` — where the open roles are | | `openJobCountIsCapped` | boolean | Present & `true` only when the sample hit `maxJobsPerCompany`. Then `openJobCount` and `postedLast7d/30d/90d` are **lower bounds**, `oldestJobDate` / `topDepartments` / `topLocations` describe the sample only | | `jobs` | array | Full job list `[{ jobId, jobUrl, title, location, postedDate }]` (when **Include jobs** is on) | | `sources` | object | Provenance — `{ hiringSignals, firmographics }` | | `note` | string | Present only when the company id can't be resolved (firmographics-only record) | | `source` / `scrapedAt` | string | `"LinkedIn (public)"` + ISO scrape timestamp | #### Sample output Illustrative record (values shown for shape, not a live pull): ```json { "companyName": "Stripe", "companySlug": "stripe", "companyLinkedInUrl": "https://www.linkedin.com/company/stripe", "companyId": "3641377", "companyDomain": "stripe.com", "employeeCount": 8000, "industry": "Software Development", "hq": "South San Francisco, California, US", "followers": 1284003, "website": "https://stripe.com", "founded": 2010, "hiringSignalsCollected": true, "openJobCount": 143, "isHiring": true, "hiringMomentum": "high", "momentumMeasurable": true, "postedLast7d": 12, "postedLast30d": 47, "postedLast90d": 118, "topDepartments": [ { "name": "Engineering", "count": 58 }, { "name": "Sales", "count": 22 }, { "name": "Product", "count": 14 } ], "topLocations": [ { "name": "New York, NY", "count": 31 }, { "name": "Dublin, Ireland", "count": 18 } ], "newestJobDate": "2026-07-04", "oldestJobDate": "2026-03-20", "jobs": [ { "jobId": "3901234567", "jobUrl": "https://www.linkedin.com/jobs/view/3901234567", "title": "Senior Software Engineer, Payments", "location": "New York, NY", "postedDate": "2026-07-04" } ], "sources": { "hiringSignals": "LinkedIn public jobs (f_C)", "firmographics": "LinkedIn company page" }, "source": "LinkedIn (public)", "scrapedAt": "2026-07-05T09:12:44.001Z" } ``` ### Input & filters - **Companies** — the list to track, as LinkedIn company URLs or bare slugs (`stripe`, `https://www.linkedin.com/company/datadog/`). One record is returned per company. - **Max jobs per company** — cap on how many open roles to sample per company for the signal computation (1–1000). Raise it for an exact `openJobCount` on large employers; lower it for faster, lighter runs. **A low cap costs you the velocity signal:** when the sample is truncated, counts become lower bounds and `hiringMomentum` returns `unknown (capped)` rather than a number that would really be measuring your cap. Keep it at the default 200 (or higher) if you rank accounts by momentum. - **Include full job list** — attach the `jobs[]` array (title, location, posted date, URL). Turn off for compact signals-only output. - **Enrich with firmographics** — add employee count, industry, HQ, domain & followers from the company's public page. On by default — it's what turns a job list into qualified sales-intent (and it reuses the page already fetched to resolve the entity, so it adds no extra fetch). - **Proxy** — **Residential** proxy is the default and strongly recommended; LinkedIn rate-limits and blocks un-proxied and datacenter traffic. ### Example inputs (copy & paste) ```jsonc // 1) Target-account watchlist for sales intent (full job list, slug + URL mix) { "companies": ["stripe", "datadog", "https://www.linkedin.com/company/openai/"], "maxJobsPerCompany": 300 } // 2) Compact, fast signals-only — no job array, lighter cap { "companies": ["shopify", "gitlab", "snowflake"], "includeJobs": false, "maxJobsPerCompany": 100 } // 3) Deep pull with firmographics + every open role { "companies": ["notion", "figma"], "includeJobs": true, "enrichCompany": true, "maxJobsPerCompany": 500 } // 4) Momentum only — no firmographics, no job array (fastest scan) { "companies": ["airbnb", "uber", "doordash"], "includeJobs": false, "enrichCompany": false, "maxJobsPerCompany": 150 } // 5) Single-account deep monitor via company URL { "companies": ["https://www.linkedin.com/company/anthropic/"], "maxJobsPerCompany": 1000 } // 6) Portfolio / territory screen — many accounts, enriched for scoring { "companies": ["plaid", "brex", "ramp", "mercury", "deel", "rippling"], "enrichCompany": true, "maxJobsPerCompany": 200 } ``` ### Use cases - **Sales intent / buying signals.** Feed your target-account list → surface which accounts are *ramping* the team you sell to. `hiringMomentum: "high"` plus a jump in `postedLast30d` for Sales or Engineering is a timing trigger your reps can act on today — not a stale firmographic. - **Competitive & market intelligence.** Track rivals over scheduled runs → watch `topDepartments` and `topLocations` shift to see where a competitor is investing (new GTM motion, a new engineering hub, a market entry) before it's public. - **Recruiting & talent-market mapping.** See which companies are hiring for a function and where demand is concentrated, to time outreach and benchmark your own req load. - **CRM enrichment & scoring.** Already have accounts? Match on `companyDomain` → append employee count, industry, HQ and a live hiring-momentum score. Missing values return `null`, never a guess. - **Investment / portfolio monitoring.** Screen a sector or a portfolio for who's scaling: rank by `postedLast30d` / `postedLast90d` and momentum to spot acceleration and stalls between reporting cycles. - **Territory & account prioritisation.** Rank a whole book of accounts by hiring velocity so SDRs work the companies actually growing, not a random alphabetical list. ### Performance & throughput Each company costs one company-page fetch (which also powers firmographic enrichment — no second request) plus a paginated pull of its public job postings. Companies are processed **6 at a time**; within a company, job pages are fetched sequentially (~250 ms apart) up to your `maxJobsPerCompany` cap, and LinkedIn exposes roughly the first **1,000** public roles per company. Runtime therefore scales with *(number of companies) × (jobs sampled per company)* — so for faster, lighter runs, lower `maxJobsPerCompany` or turn **Include jobs** off. There are no external API keys; throughput is bounded by LinkedIn's public rate limits and your proxy/Apify plan. ### Integrations **JavaScript** (`apify-client`): ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('foxlabs/linkedin-hiring-signals').call({ companies: ['stripe', 'datadog', 'openai'], maxJobsPerCompany: 200, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); ``` **Python** (`apify-client`): ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("foxlabs/linkedin-hiring-signals").call(run_input={ "companies": ["stripe", "datadog", "openai"], "maxJobsPerCompany": 200, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["companyName"], item["openJobCount"], item["hiringMomentum"]) ``` Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), **scheduled runs** to build a hiring-trend time series, webhooks, and the **Apify MCP server** so AI agents can pull hiring signals on demand. ### Data quality - **Public source only.** Firmographics come from the company's public LinkedIn page (its structured `ld+json`, meta tags and About block) and hiring signals from public job postings — nothing login-gated is used. Fields LinkedIn doesn't publish for a company (e.g. `followers`, `founded`, sometimes `industry`) return `null`; values are **never fabricated or guessed**. - **Entity-resolved.** Each company is matched to its numeric LinkedIn id and `companyDomain`, so records join on domain rather than fuzzy name-matching. - **Velocity is measured, not estimated.** `postedLast7d/30d/90d` are counted from each posting's own `datetime`, within the sampled set (`maxJobsPerCompany`). - **What wasn't measured is never reported as a negative.** If the cap truncated the sample, momentum returns `unknown (capped)` instead of a confident `low`; if the company id never resolved, the hiring fields are absent (`hiringSignalsCollected: false`) instead of `0` / `not-hiring`. You can tell "we looked and found nothing" from "we couldn't look". - **Departments are inferred.** `topDepartments` is derived from job-title keywords — a strong approximation, not LinkedIn's internal taxonomy. ### Pricing **Pay per company** — you're billed per company record returned. Firmographic enrichment reuses the single company-page fetch already needed to resolve the entity, so it adds signal without adding cost. There's an Apify **free tier** to evaluate the full output before you scale, and no third-party API or proxy fees beyond your Apify plan. ### FAQ **What exactly is a "hiring signal"?** For each company you get its current open-role count, whether it's hiring, a momentum label, 7/30/90-day posting velocity, and a department & location breakdown — computed from its public LinkedIn job postings and paired with firmographics. **How is `hiringMomentum` computed?** Transparently, from posting counts: `not-hiring` = 0 open roles; `high` = 5+ posted in the last 7 days **or** 15+ in the last 30; `medium` = 5+ in the last 30 (and not high); `low` = at least one open role but below the medium threshold. **When is `hiringMomentum` `unknown (capped)`?** When the sample hit `maxJobsPerCompany`, so the true counts are higher than what was counted. The thresholds above are then unreachable by construction — at `maxJobsPerCompany: 3`, `high` needs 5 postings in 7 days, so *every* company would come back `low` and the label would be measuring your cap, not the company. In that case the Actor returns `hiringMomentum: "unknown (capped)"` with `momentumMeasurable: false` and keeps the raw counts as lower bounds (`openJobCountIsCapped: true`). One exception: if the truncated sample **already** clears the `high` thresholds, `high` is still exact — more roles can only push it higher — so `high` is reported with `momentumMeasurable: true`. Raise the cap for a measurable label. **Do I need a LinkedIn login or cookies?** No. Everything is read from public pages — cookieless. **How do I specify companies?** As full LinkedIn company URLs (`https://www.linkedin.com/company/stripe/`) or bare slugs (`stripe`). Duplicates and country subdomains are normalised automatically. **A common name resolved to the wrong company — why?** A bare slug follows LinkedIn's `/company/{slug}` page, which for common names may point at a namesake. Check the returned `companyDomain` to verify the match, and for well-known names pass the **exact** company URL. **How many jobs are counted per company?** Up to `maxJobsPerCompany` (1–1000). LinkedIn itself exposes roughly the first 1,000 public roles per company. **What does `openJobCountIsCapped` mean?** It's present and `true` when `openJobCount` reached your cap. `openJobCount` and `postedLast7d/30d/90d` are then **lower bounds**, `oldestJobDate` / `topDepartments` / `topLocations` describe the sampled roles only, and `hiringMomentum` is reported as `unknown (capped)` unless it already clears the `high` thresholds. Raise `maxJobsPerCompany` for exact figures. **Are `topDepartments` official LinkedIn categories?** No — they're inferred from job-title keywords. Treat them as a reliable approximation, not LinkedIn's own taxonomy. **What export formats are available?** JSON, CSV, Excel, or via the Apify API / integrations. **Is this affiliated with LinkedIn?** No. It is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation, and reads only public data. ### Troubleshooting - **`hiringSignalsCollected: false` / no hiring fields at all** → the company id couldn't be resolved, so the job feed was never queried (the record carries a `note` and firmographics only). That is *not* a "not hiring" verdict. Pass the **exact** LinkedIn company URL and check `companyId` is populated. - **`hiringMomentum: "unknown (capped)"` on every company** → your `maxJobsPerCompany` is too low for the momentum thresholds (see the FAQ). Raise it to 200+ and momentum becomes measurable again. - **A record with `error: "company page unreachable"`** → the public page didn't load (rate-limit or a transient block). Use the default **Residential** proxy and re-run; smaller batches help. - **Wrong company matched** → slug ambiguity. Use the exact `/company/{slug}` URL and confirm via `companyDomain`. - **Fewer roles than expected / `openJobCountIsCapped: true`** → raise `maxJobsPerCompany` (up to 1000) for a complete count on large employers. ### Notes, limits & legal (honest) - **Public data only, cookieless.** Signals are computed from public LinkedIn postings; a company's public page must be resolvable. If the company id can't be resolved, the record returns firmographics only, `hiringSignalsCollected: false` and a `note` — the hiring fields are omitted rather than zeroed, because nothing was measured. - **Slug ambiguity.** A bare slug follows `/company/{slug}`, which for common names may resolve to a different company than intended. The returned `companyDomain` lets you verify — pass the exact company URL for certainty. - **Capped counts.** `openJobCount` is capped at `maxJobsPerCompany`; when the cap is hit, `openJobCountIsCapped: true` is set and every count (including 7/30/90-day velocity) is a **lower bound**. Because the momentum thresholds then can't be evaluated honestly, `hiringMomentum` returns `unknown (capped)` with `momentumMeasurable: false` — unless the truncated sample already clears the `high` thresholds, which stays exact. - **Inferred departments.** `topDepartments` is inferred from job titles — a strong approximation, not LinkedIn's internal taxonomy. - **Not affiliated** with, endorsed by, or sponsored by LinkedIn Corporation. This Actor reads public data. **You are responsible** for using the output lawfully — respect LinkedIn's Terms of Service and applicable data-protection law (e.g. GDPR) for your use case and jurisdiction. LinkedIn has no official public jobs/company API; if you need licensed data, use LinkedIn's own products. ### Support Questions, a field you'd like added, or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast. *If this Actor saves you time, a ⭐ review really helps.* ### Changelog #### 0.4.1 — 2026-07-28 - **Fixed: every company handle containing a hyphen silently returned nothing.** Apify proxy session IDs accept only `[\w.~]`, so a handle like `red-bull` or `palo-alto-networks` made the proxy call throw — and the throw was swallowed by the retry loop, so the company came back empty instead of erroring. Handles are now sanitised before the proxy session is created. Most multi-word brands were affected. #### 0.4 — 2026-07-28 - **Momentum no longer measures your cap.** When the job sample is truncated at `maxJobsPerCompany`, the posting-count thresholds behind `hiringMomentum` become unreachable by construction (at a cap of 3, `high` needs 5 postings in 7 days — so every company came back `low`). Truncated samples now return `hiringMomentum: "unknown (capped)"` with `momentumMeasurable: false`, and the raw counts are kept as explicit lower bounds via `openJobCountIsCapped`. A truncated sample that already clears the `high` thresholds still reports `high` — more roles can only push it higher. Uncapped runs are unchanged. - **Unresolvable company id no longer reads as "not hiring".** When the LinkedIn company id can't be resolved the job feed is never queried, so the record now carries `hiringSignalsCollected: false` and omits the hiring fields instead of publishing `openJobCount: 0` / `isHiring: false` / `hiringMomentum: "not-hiring"` — which contradicted the `note` on the same record. - **`founded` now actually fills.** LinkedIn's public company `ld+json` carries no `foundingDate`, so the field was `null` on every record; the founding year is now read from the visible About block (verified against live company HTML), with a year-sanity guard so a full date can't leak through as `20100101`. - Documented the `ownership` (KYB) field in the output table. #### 0.3 — 2026-07-16 - **Ultimate beneficial owner (KYB).** Each company is now resolved to its ultimate beneficial owner — a real person or a cross-border parent — by walking UK holding-company ownership chains (Companies House PSC + GLEIF). See who *really* controls the companies you're tracking (e.g. one owned via layers by a US or private-equity parent). Confidence-gated: the owner is attached only when resolved with high confidence, never guessed. New `includeOwnership` option (on by default). No other hiring-signals scraper links companies to real ownership. #### 0.2 — 2026-07-05 - Reworked docs: API quick-start, full field table, sample output, input recipes, JS/Python/Make/MCP integrations, FAQ & troubleshooting, and honest legal notes. #### 0.1 - Initial release. Company-centric hiring signals (open roles, 7/30/90-day velocity, momentum, department & location breakdown, full job list) + inline firmographic enrichment + provenance. Cookieless. *** Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — public-data company, jobs, procurement, contact & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**. # Actor input Schema ## `companies` (type: `array`): LinkedIn company URLs or slugs to track — e.g. "stripe", "https://www.linkedin.com/company/datadog/". One hiring-signal record is returned per company. ## `maxJobsPerCompany` (type: `integer`): Cap on how many open roles to pull per company for the signal computation (1–1000). ## `maxResults` (type: `integer`): Maximum number of company hiring-signal records to return — helps control cost. Set 0 for unlimited. ## `includeJobs` (type: `boolean`): Include the array of individual open jobs (title, location, posted date, URL) in each company record. Turn off for compact signals-only output. ## `enrichCompany` (type: `boolean`): Add employer firmographics (employee count, industry, HQ, website domain, followers) from the company's public LinkedIn page. On by default — it's what turns a job list into qualified sales-intent. ## `includeOwnership` (type: `boolean`): Resolve each company to its ULTIMATE beneficial owner — a real person or a cross-border parent company — by walking UK holding-company ownership chains (Companies House PSC + GLEIF). E.g. a company owned via layers by a US or PE parent. Confidence-gated: the owner is only attached when it can be resolved with high confidence (never guessed). Requires company enrichment. ## `proxyConfiguration` (type: `object`): Proxy configuration. Residential proxy (the default) is strongly recommended — LinkedIn rate-limits and blocks un-proxied and datacenter traffic. ## Actor input object example ```json { "companies": [ "stripe", "datadog", "openai" ], "maxJobsPerCompany": 200, "maxResults": 500, "includeJobs": true, "enrichCompany": true, "includeOwnership": true, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `dataset` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "companies": [ "stripe", "datadog", "openai" ], "maxJobsPerCompany": 200, "maxResults": 500, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("foxlabs/linkedin-hiring-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "companies": [ "stripe", "datadog", "openai", ], "maxJobsPerCompany": 200, "maxResults": 500, "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("foxlabs/linkedin-hiring-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 '{ "companies": [ "stripe", "datadog", "openai" ], "maxJobsPerCompany": 200, "maxResults": 500, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call foxlabs/linkedin-hiring-signals --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=foxlabs/linkedin-hiring-signals", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/acts/vBpvdhZC0rrXiyipG/builds/3m9dmHiEqptHa2ov4/openapi.json