# LinkedIn Employee Count / Company Growth Tracker (`coregent/linkedin-employee-count-company-growth-tracker`) Actor Track LinkedIn company employee counts, follower counts, company size, industry, and simple growth deltas from public company pages - no LinkedIn login or cookies required. - **URL**: https://apify.com/coregent/linkedin-employee-count-company-growth-tracker.md - **Developed by:** [Delowar Munna](https://apify.com/coregent) (community) - **Categories:** Social media, Developer tools, Lead generation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $2.40 / 1,000 company-growth-results 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/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 ## LinkedIn Employee Count / Company Growth Tracker ![LinkedIn Employee Count / Company Growth Tracker](https://raw.githubusercontent.com/coregentdevspace/linkedin-employee-count-company-growth-tracker-assets/main/thumbnail-logo-linkedin-employee-count-company-growth-tracker.jpg) Track **LinkedIn company employee counts, follower counts, company size, industry, and simple growth deltas** from **public company pages** — one clean, flat, CSV-ready row per company. Built for **B2B sales, recruiting, market research, and competitor / investor monitoring**. **No LinkedIn login, no cookies, no session IDs.** The actor reads LinkedIn's public guest company pages over HTTP, so it stays fast and cost-predictable. You pay one flat event per unique company row that passes your filters. This is a **company-level growth tracker**, not a people scraper and not an AI company-monitoring report. It does **not** scrape individual employee profiles. ### ✨ Why this scraper - **Company-level signals, not profiles** — current employee count, followers, size band, industry, HQ, website, plus growth deltas vs prior runs. - **Two input modes** — paste LinkedIn company URLs, or just company slugs (`openai`). - **Automatic growth tracking** — run it on a schedule and it remembers each company's last counts, computing `*_delta`, `*_delta_percent`, a `growth_label`, and a transparent `growth_score` on the next run. No paste-back, no setup. - **28 flat fields** — no nested objects; drops straight into Sheets/Excel/CRMs. - **Pay-Per-Event** — one flat `company-growth-result` event per saved unique company. Duplicates, filtered, not-found, and blocked rows are never charged. - **Transparent growth score** — rule-based (no AI), explained below. --- ### 🚀 Quick start — sample inputs #### Example 1 — track companies by URL + slug ```json { "companyUrls": ["https://www.linkedin.com/company/atlassian/", "https://www.linkedin.com/company/canva/"], "companySlugs": ["openai"], "maxResults": 100, "minEmployeeCount": 50, "includeDescription": true, "deduplicate": true, "compareWithPreviousData": true, "proxyConfiguration": { "useApifyProxy": true } } ```` #### Example 2 — filter a watchlist, custom residential proxy via your own provider ```json { "companySlugs": ["stripe", "notion", "figma", "databricks"], "maxResults": 250, "minEmployeeCount": 200, "industryKeywords": ["software", "technology"], "growthFilter": "any", "includeDescription": false, "deduplicate": true, "proxyConfiguration": { "useApifyProxy": false, "proxyUrls": ["http://user:pass@proxy.iproyal.com:12321"] } } ``` > Provide **at least one** of `companyUrls` or `companySlugs`. If you provide both, they are merged and deduplicated across the whole run. > The actor blocks Apify Residential proxy; if you need residential routing, supply your own provider via `proxyConfiguration.proxyUrls`. See **🚦 Proxy policy** below. *** ### 📦 Output The dataset has one view: **Company growth** — a 28-column flat table. ![LinkedIn Employee Count / Company Growth Tracker — all-fields table view](https://raw.githubusercontent.com/coregentdevspace/linkedin-employee-count-company-growth-tracker-assets/main/linkedin-employee-count-company-growth-tracker-output-company-growth-table-view.png) #### Output fields (28) `input_company`, `input_type`, `company_name`, `company_slug`, `linkedin_company_url`, `linkedin_company_id`, `employee_count`, `employee_count_text`, `company_size_band`, `follower_count`, `follower_count_text`, `industry`, `headquarters`, `country`, `website`, `description`, `previous_employee_count`, `employee_count_delta`, `employee_count_delta_percent`, `previous_follower_count`, `follower_count_delta`, `follower_count_delta_percent`, `previous_scraped_at`, `growth_label`, `growth_score`, `reason_tags`, `source_status`, `scraped_at`. #### Sample record — Company growth ```json { "input_company": "https://www.linkedin.com/company/atlassian/", "input_type": "url", "company_name": "Atlassian", "company_slug": "atlassian", "linkedin_company_url": "https://www.linkedin.com/company/atlassian/", "linkedin_company_id": "22688", "employee_count": 21120, "employee_count_text": "21,120 employees", "company_size_band": "10,001+ employees", "follower_count": 2487598, "follower_count_text": "2,487,598 followers", "industry": "Software Development", "headquarters": "Sydney, NSW", "country": "Australia", "website": "https://atlassian.com/", "description": "Atlassian powers the collaboration that helps teams accomplish what would otherwise be impossible alone. From space missions and motor racing to bugs in code and IT requests, no task is too large or too small with the right team, the right tools, and the right practices. Over 300,000 global companies and 80% of the Fortune 500 rely on Atlassian's software, like Jira, Confluence, Loom, and Trello, to help their teams work better together and deliver quality results on time.", "previous_employee_count": 21120, "employee_count_delta": 0, "employee_count_delta_percent": 0, "previous_follower_count": 2487577, "follower_count_delta": 21, "follower_count_delta_percent": 0, "previous_scraped_at": "2026-05-30T00:17:22.051Z", "growth_label": "stable", "growth_score": 65, "reason_tags": "employee_count_available|follower_count_available|previous_snapshot_matched|company_size_available", "source_status": "ok", "scraped_at": "2026-05-30T00:43:01.254Z" } ``` > Real output from a back-to-back run, so the deltas here are small and the label is `stable`. Over daily/weekly schedules the `*_delta` fields and `growth_label` (`growing` / `declining`) reflect real headcount and follower movement. *** ### 🎯 Growth score Transparent rule-based score (0–100) computed from extracted fields and run-over-run deltas — no AI, no external enrichment. Starts at **50**, then: | Signal | Points | | ------------------------------------- | -----: | | Employee count delta ≥ 10% | +25 | | Employee count delta ≥ 3% and < 10% | +15 | | Follower count delta ≥ 10% | +10 | | Follower count delta ≥ 3% and < 10% | +5 | | Employee count ≥ 50 | +5 | | Employee count ≥ 200 | +5 | | Company size band present | +5 | | Employee count delta ≤ -10% | −25 | | Employee count delta < -3% and > -10% | −15 | | Follower count delta ≤ -10% | −10 | | Follower count delta < -3% and > -10% | −5 | | Employee count missing | −10 | Score is clamped to **0–100**. **Growth label**: `growing` (employee delta ≥ 3% or follower delta ≥ 10%) · `declining` (employee delta ≤ -3% or follower delta ≤ -10%) · `stable` (a previous count exists but no threshold met) · `unknown` (no previous count available). `reason_tags` is a pipe-separated list explaining the row — e.g. `employee_count_available`, `follower_count_available`, `previous_snapshot_matched`, `employee_growth_positive`, `follower_growth_positive`, `company_size_available`, `missing_previous_snapshot`, `missing_employee_count`. *** ### 📈 Tracking growth over time Growth deltas come for free across runs — **no paste-back needed**. With `compareWithPreviousData` on (default), the actor remembers each company's last-known employee/follower counts in a persistent store and diffs against them automatically on the next run: 1. **First run** — no prior data yet, so deltas are `null` and `growth_label` is `unknown`. Counts are saved to the store. 2. **Next run(s)** — each company is matched to its last-known counts (by canonical URL, then slug) and `*_delta`, `*_delta_percent`, `growth_label`, `growth_score`, and `previous_scraped_at` are computed. The store is then updated with the fresh counts. Because the store keeps the **last-known value per company**, a company's baseline can come from an *earlier* run, not just the immediate previous one — so changing company lists and gaps are handled gracefully (a company with no prior data simply comes back `unknown`). - **`historyStoreName`** — set this to isolate separate tracking sets (e.g. one per watchlist). Leave empty for a sensible per-task default. The store is account-scoped and behaves the same locally and on Apify. - **`compareWithPreviousData: false`** — disables tracking entirely (no store reads/writes; all rows come back `unknown`). Just schedule the actor (daily/weekly/monthly) and growth is tracked for you. *** ### 💰 Pricing **Pay-Per-Event**. One flat event per saved row (final per-event price is configured on the Apify console): | Event | Charged when | | ----------------------- | ------------------------------------------------------------------------------------------------ | | `company-growth-result` | Once per unique company row that passed all filters and was successfully written to the dataset. | So your bill is simply `results_saved × price_per_event`. The actor honors the user-configured per-run spending cap (Apify `eventChargeLimitReached`): it caps how many companies it fetches up-front to what the limit can pay for, and stops cleanly the moment the cap is reached during charging. Not charged: - Duplicates (deduplicated by company ID, canonical URL, slug, and name+website/HQ keys). - Rows filtered out by employee / follower / industry / growth filters. - Not-found, blocked, or failed company pages. #### 🚦 Proxy policy Use **Apify Datacenter** proxy or **no proxy** for normal runs — both work for LinkedIn's public guest company pages at this actor's conservative concurrency. **Apify Residential proxy is not supported.** The actor will fail at startup if `proxyConfiguration.apifyProxyGroups` includes `RESIDENTIAL`. Reason: in pay-per-event actors, residential bandwidth (~/GB) is billed to the developer, not the run user, so a single bandwidth-heavy run could exceed the per-result event revenue. If you genuinely need residential routing, supply your own residential provider via the proxy editor's **Custom proxy URLs** field — that traffic goes through your provider, not Apify, and is unaffected: ``` http://user:pass@proxy.iproyal.com:12321 http://user:pass@proxy.brightdata.com:22225 http://user:pass@proxy.oxylabs.io:7777 ``` *** ### 📊 Run summary After each run, a `RUN_SUMMARY` entry is written to the key-value store: ```json { "inputs_total": 120, "unique_inputs": 115, "successful_inputs": 101, "failed_inputs": 8, "blocked_requests": 6, "raw_results_found": 104, "results_saved": 92, "duplicates_removed": 5, "filtered_out": 7, "previous_snapshots_matched": 65, "history_entries_loaded": 110, "history_entries_saved": 92, "growing_companies": 24, "stable_companies": 36, "declining_companies": 5, "unknown_growth_companies": 27, "charged_events": 92, "charge_failures": 0, "retry_count": 18, "runtime_seconds": 410, "scraped_at": "2026-05-25T05:00:00.000Z" } ``` `charged_events` equals the number of successfully saved unique rows. *** ### ⚙️ Filters | Filter | Effect | | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | | `minEmployeeCount` / `maxEmployeeCount` | Keep companies within the employee-count bounds. Missing counts are dropped when a bound is set. | | `minFollowerCount` | Keep companies with at least this many followers. Missing counts dropped when > 0. | | `industryKeywords` | Case-insensitive substring match on `industry`. Missing industry dropped when keywords given. | | `growthFilter` | `any` / `growing` / `stable` / `declining` / `unknown` (meaningful once prior data exists, i.e. from the 2nd run on). | | `deduplicate` | One row per canonical company (recommended ON). | Filters are applied **after** extraction and scoring, and **before** any dataset push or event charge. *** ### 🚧 Limitations (V1) - **Public guest data only**: no login, cookies, or member-only content. LinkedIn gates some company pages for guests; when a page is gated the company is reported as `blocked`/`partial` in the summary and not charged. Use Apify Proxy and keep runs modest for best coverage. - **Best-effort fields**: `employee_count`, `follower_count`, `company_size_band`, `industry`, `headquarters`, and `website` populate only when LinkedIn shows them on the public page. Missing values are `null` and the row is marked `partial`. - **Growth deltas need a prior run** — the first run for a given company has no stored baseline, so `growth_label` is `unknown` and delta fields are `null`; deltas appear from the second run onward (with `compareWithPreviousData` on). - **No people scraping**: no employee lists, new-hire detection, department/location breakdowns, job-page analytics, contact/email enrichment, website crawling, or AI narratives. - `maxResults` caps **saved unique** rows across the whole run. *** ### ❓ FAQ **Do I need a LinkedIn account or cookies?** No. The actor only reads LinkedIn's public guest company pages. **Why are some fields null / why is a row `partial`?** LinkedIn does not always expose every field publicly, and some pages are gated for guests. The actor returns whatever is visible and marks incomplete rows `partial`. **How do I get growth deltas?** Just run the actor more than once — with `compareWithPreviousData` on (default) it remembers each company's last counts and computes deltas automatically on the next run, no paste-back needed. See **📈 Tracking growth over time**. **Can I pass just slugs?** Yes — put them in `companySlugs` (e.g. `openai`). They become `https://www.linkedin.com/company//`. **Can I export to CSV?** Yes — every field is flat (no nested objects). Use Apify's CSV / Excel export, or call the dataset API with `format=csv`. **Will I get blocked?** The actor uses conservative concurrency, realistic headers, session rotation, and retry/backoff. Default Apify Proxy is sufficient for typical small/medium runs. For large runs, split the list and/or supply your own proxy provider. *** ### 🛠️ Technical notes - **Stack**: Node.js 22 · Apify SDK 3 · Crawlee `CheerioCrawler` · Cheerio + native fetch. No browser. - **Surface**: LinkedIn public guest company page (`/company//`); parsed via JSON-LD, `og:` meta, and visible top-card / about text. - **Concurrency**: `min=1`, `max=5` (conservative; tune after real runs). - **Memory**: 1 GB min · 2 GB default · 4 GB max. - **Proxy**: Apify Proxy enabled by default; custom configs accepted; Apify Residential rejected at startup. # Actor input Schema ## `companyUrls` (type: `array`): LinkedIn company page URLs to track, e.g. https://www.linkedin.com/company/atlassian/. Provide at least one of Company URLs or Company slugs. ## `companySlugs` (type: `array`): Company slugs instead of full URLs, e.g. "openai". Each is converted to https://www.linkedin.com/company//. ## `compareWithPreviousData` (type: `boolean`): Automatically remember each company's last-known employee/follower counts in a persistent store and compute growth deltas on the next run - no need to paste previous output. The first run has no history yet, so its growth fields are 'unknown'; deltas appear from the second run onward. ## `historyStoreName` (type: `string`): Optional name for the persistent history store, to keep separate tracking sets isolated (e.g. one per watchlist). Leave empty to use a per-task default (or a shared default when not run as a task). ## `maxResults` (type: `integer`): Maximum number of saved unique company rows across the whole run. Range 1-5000. ## `minEmployeeCount` (type: `integer`): Keep only companies with at least this many employees. Companies with a missing employee count are dropped when this is greater than 0. ## `maxEmployeeCount` (type: `integer`): Keep only companies with at most this many employees. Leave empty for no upper limit. When set, companies with a missing employee count are dropped. ## `minFollowerCount` (type: `integer`): Keep only companies with at least this many followers. Companies with a missing follower count are dropped when this is greater than 0. ## `industryKeywords` (type: `array`): Keep only companies whose industry contains one of these terms (case-insensitive). Leave empty to keep all. Companies with a missing industry are dropped when keywords are provided. ## `growthFilter` (type: `string`): Keep only companies with this growth label. Meaningful only when previous snapshots are provided; otherwise most rows are "unknown". ## `includeDescription` (type: `boolean`): Include the company description field when visible on the page (no extra requests). Turn off to keep rows leaner. ## `deduplicate` (type: `boolean`): Remove duplicate company records so you get one row per canonical company and are not charged for duplicates. ## `proxyConfiguration` (type: `object`): Apify Proxy configuration. Defaults to Apify Proxy enabled. Apify Residential is NOT supported and will fail the run at startup; if you need residential routing, supply your own provider via Custom proxy URLs (proxyUrls). ## Actor input object example ```json { "companyUrls": [ "https://www.linkedin.com/company/atlassian/", "https://www.linkedin.com/company/canva/" ], "companySlugs": [ "openai" ], "compareWithPreviousData": true, "historyStoreName": "", "maxResults": 100, "minEmployeeCount": 0, "minFollowerCount": 0, "industryKeywords": [], "growthFilter": "any", "includeDescription": true, "deduplicate": true, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `overview` (type: `string`): Flat 28-field table view of every company row pushed to the dataset: identity, employee/follower counts, size band, industry, headquarters, website, and derived growth deltas/label/score. # 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 = { "companyUrls": [ "https://www.linkedin.com/company/atlassian/", "https://www.linkedin.com/company/canva/" ], "companySlugs": [ "openai" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("coregent/linkedin-employee-count-company-growth-tracker").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 = { "companyUrls": [ "https://www.linkedin.com/company/atlassian/", "https://www.linkedin.com/company/canva/", ], "companySlugs": ["openai"], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("coregent/linkedin-employee-count-company-growth-tracker").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 '{ "companyUrls": [ "https://www.linkedin.com/company/atlassian/", "https://www.linkedin.com/company/canva/" ], "companySlugs": [ "openai" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call coregent/linkedin-employee-count-company-growth-tracker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=coregent/linkedin-employee-count-company-growth-tracker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "LinkedIn Employee Count / Company Growth Tracker", "description": "Track LinkedIn company employee counts, follower counts, company size, industry, and simple growth deltas from public company pages - no LinkedIn login or cookies required.", "version": "1.0", "x-build-id": "PXp3Wa0dfySmbWyR8" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/coregent~linkedin-employee-count-company-growth-tracker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-coregent-linkedin-employee-count-company-growth-tracker", "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/coregent~linkedin-employee-count-company-growth-tracker/runs": { "post": { "operationId": "runs-sync-coregent-linkedin-employee-count-company-growth-tracker", "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/coregent~linkedin-employee-count-company-growth-tracker/run-sync": { "post": { "operationId": "run-sync-coregent-linkedin-employee-count-company-growth-tracker", "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": { "companyUrls": { "title": "LinkedIn company URLs", "type": "array", "description": "LinkedIn company page URLs to track, e.g. https://www.linkedin.com/company/atlassian/. Provide at least one of Company URLs or Company slugs.", "default": [], "items": { "type": "string" } }, "companySlugs": { "title": "LinkedIn company slugs", "type": "array", "description": "Company slugs instead of full URLs, e.g. \"openai\". Each is converted to https://www.linkedin.com/company//.", "default": [], "items": { "type": "string" } }, "compareWithPreviousData": { "title": "Auto-compare with previous runs", "type": "boolean", "description": "Automatically remember each company's last-known employee/follower counts in a persistent store and compute growth deltas on the next run - no need to paste previous output. The first run has no history yet, so its growth fields are 'unknown'; deltas appear from the second run onward.", "default": true }, "historyStoreName": { "title": "History store name (advanced)", "type": "string", "description": "Optional name for the persistent history store, to keep separate tracking sets isolated (e.g. one per watchlist). Leave empty to use a per-task default (or a shared default when not run as a task).", "default": "" }, "maxResults": { "title": "Max results", "minimum": 1, "maximum": 5000, "type": "integer", "description": "Maximum number of saved unique company rows across the whole run. Range 1-5000.", "default": 100 }, "minEmployeeCount": { "title": "Minimum employee count", "minimum": 0, "type": "integer", "description": "Keep only companies with at least this many employees. Companies with a missing employee count are dropped when this is greater than 0.", "default": 0 }, "maxEmployeeCount": { "title": "Maximum employee count", "minimum": 1, "type": "integer", "description": "Keep only companies with at most this many employees. Leave empty for no upper limit. When set, companies with a missing employee count are dropped." }, "minFollowerCount": { "title": "Minimum follower count", "minimum": 0, "type": "integer", "description": "Keep only companies with at least this many followers. Companies with a missing follower count are dropped when this is greater than 0.", "default": 0 }, "industryKeywords": { "title": "Industry keywords", "type": "array", "description": "Keep only companies whose industry contains one of these terms (case-insensitive). Leave empty to keep all. Companies with a missing industry are dropped when keywords are provided.", "default": [], "items": { "type": "string" } }, "growthFilter": { "title": "Growth label filter", "enum": [ "any", "growing", "stable", "declining", "unknown" ], "type": "string", "description": "Keep only companies with this growth label. Meaningful only when previous snapshots are provided; otherwise most rows are \"unknown\".", "default": "any" }, "includeDescription": { "title": "Include description", "type": "boolean", "description": "Include the company description field when visible on the page (no extra requests). Turn off to keep rows leaner.", "default": true }, "deduplicate": { "title": "Deduplicate companies", "type": "boolean", "description": "Remove duplicate company records so you get one row per canonical company and are not charged for duplicates.", "default": true }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Apify Proxy configuration. Defaults to Apify Proxy enabled. Apify Residential is NOT supported and will fail the run at startup; if you need residential routing, supply your own provider via Custom proxy URLs (proxyUrls).", "default": { "useApifyProxy": true } } } }, "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 } } } } } } } } } } ```