# Owler Company Intelligence Scraper (`automation-lab/owler-company-intelligence-scraper`) Actor

🏢 Enrich company names, domains, or Owler URLs with public firmographics, revenue and employee estimates, leaders, competitors, funding, M\&A, and news.

- **URL**: https://apify.com/automation-lab/owler-company-intelligence-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.28 / 1,000 company processeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Owler Company Intelligence Scraper

Turn company names, website domains, or public Owler profile URLs into structured company intelligence.

The Actor extracts public firmographics, revenue and employee estimates, leadership, ranked competitors, funding, acquisitions, investments, and recent news from Owler company profiles.

Use the results in CRM enrichment, account research, competitive monitoring, market maps, and investment watchlists.

No Owler login is required for the public profile data supported by this Actor.

### What does Owler Company Intelligence Scraper do?

Owler Company Intelligence Scraper resolves each supplied company and saves one structured dataset row per company.

You can start from:

- 🌐 website domains such as `apple.com`;
- 🏷️ company names such as `Apple`;
- 🔗 public Owler company URLs such as `https://www.owler.com/company/apple`.

Domain inputs use exact domain matching whenever Owler returns a matching profile.

Name inputs use Owler's public company search.

Explicit URLs skip search and go directly to the selected public company profile.

### Why use this Owler scraper?

Copying company profiles by hand is slow and difficult to repeat.

This Actor gives you a stable automation contract:

- one row per company;
- consistent field names across companies;
- exact source URLs for traceability;
- deterministic deduplication;
- typed error rows instead of silently missing inputs;
- optional nested sections to keep exports focused.

The output is ready for JSON, CSV, Excel, API, webhook, and database workflows.

### Who is it for?

#### Sales and RevOps teams

Enrich account records with industry, headquarters, employee range, revenue range, ownership, and executive context.

#### Competitive-intelligence teams

Refresh ranked competitor sets and compare company scale, proximity scores, funding, and market activity.

#### Investors and analysts

Build recurring watchlists containing funding rounds, acquisitions, investments, leadership, and news signals.

#### Data engineers

Feed normalized company records into warehouses, enrichment pipelines, lead-scoring models, or entity-resolution systems.

#### Founders and consultants

Research markets and benchmark a target company against the competitors Owler ranks most closely.

### What company data can you extract?

| Field group | Example fields |
|---|---|
| Identity | company ID, name, short name, description, source URL, website, domain, logo |
| Firmographics | ownership, status, founded year, industries, SIC codes, address, headquarters, phone |
| Company size | employee estimate, formatted employees, employee range |
| Revenue | estimated revenue in USD, formatted revenue, revenue range |
| Leadership | CEO name, designation, rating, photo, LinkedIn, Twitter, leadership team |
| Competition | rank, proximity score, competitor website, revenue, employees, funding, HQ |
| Funding | total funding, round count, rounds, dates, amounts, named investors, funding by year |
| Corporate activity | acquisition records, investment records, total counts |
| News | category, title, description, publication time, source, business signals |
| Provenance | original input, input type, source URL, scrape timestamp, error |

Fields are omitted when Owler does not expose them for a company.

Numeric estimates and their display ranges are preserved separately.

### Ranked competitor data

Owler's company graph is a core reason to use this scraper.

Each available competitor can include:

- rank in the profile list;
- Owler company ID;
- company name and profile URL;
- website and domain;
- proximity score;
- ownership and founding year;
- industries and headquarters;
- employee estimate and range;
- revenue estimate and range;
- total funding estimate.

Set `includeCompetitors` to `false` when you only need the main company record.

### Funding, acquisitions, and investments

Set the relevant toggles to include or omit capital and corporate-activity sections.

Funding records can contain the round name, date, amount, display range, and named investors.

The funding summary also preserves Owler's total amount, total round count, and annual chart data when available.

Acquisitions and investments vary by company.

The Actor returns the public records present in the profile state without inventing missing values.

### Recent company news

With `includeNews` enabled, the Actor combines available profile highlights and recent news entries.

A news row can contain:

- category or event type;
- headline;
- description;
- publication timestamp;
- source name;
- source or Owler report URL;
- sales-trigger labels.

Use these records to support account alerts, market monitoring, and research updates.

### How to scrape Owler company data

1. Open the Actor input page.
2. Paste domains, names, public Owler URLs, or a combination.
3. Keep the initial `maxItems` low for a quick test.
4. Choose which intelligence sections to include.
5. Click **Start**.
6. Review the **Company intelligence** dataset view.
7. Export the data or connect an integration.

The three input routes merge into one deduplicated queue.

### Input reference

| Input | Type | Default | Description |
|---|---|---:|---|
| `companyDomains` | string array | — | Website domains; best for CRM enrichment and exact matching |
| `companyNames` | string array | — | Company names resolved through public Owler search |
| `startUrls` | request list | — | Public Owler `/company/...` or `/iaApp/...company-profile` URLs |
| `maxItems` | integer | 10 | Maximum unique rows, including unresolved-input rows |
| `maxConcurrency` | integer | 3 | Parallel lookups; maximum 10 |
| `includeLeadership` | boolean | true | Include CEO and leadership records |
| `includeCompetitors` | boolean | true | Include ranked competitors |
| `includeFunding` | boolean | true | Include funding summary and rounds |
| `includeAcquisitions` | boolean | true | Include acquisition records |
| `includeInvestments` | boolean | true | Include investment records |
| `includeNews` | boolean | true | Include recent news and highlights |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings; tested default is datacenter |

At least one company source is required.

### Example input: CRM account enrichment

```json
{
  "companyDomains": [
    "apple.com",
    "salesforce.com",
    "stripe.com"
  ],
  "maxItems": 3,
  "maxConcurrency": 3,
  "includeCompetitors": true,
  "includeFunding": true
}
````

Domains are normalized, so `https://www.apple.com/` and `apple.com` resolve to the same input key.

### Example input: competitor research

```json
{
  "companyNames": [
    "Microsoft",
    "Google",
    "Shopify"
  ],
  "maxItems": 3,
  "includeCompetitors": true,
  "includeLeadership": true,
  "includeFunding": false,
  "includeNews": true
}
```

Use exact domains instead of ambiguous one-word names when possible.

### Example input: one public Owler URL

```json
{
  "startUrls": [
    { "url": "https://www.owler.com/company/owler" }
  ],
  "maxItems": 1
}
```

URLs on other hosts or unrelated Owler page types are rejected before scraping.

### Example output

```json
{
  "input": "owler.com",
  "inputType": "domain",
  "sourceUrl": "https://www.owler.com/company/owler",
  "companyId": 100486,
  "name": "Owler, Inc.",
  "shortName": "Owler",
  "website": "https://www.owler.com/",
  "domain": "owler.com",
  "ownership": "Private",
  "foundedYear": 2011,
  "headquarters": "San Francisco, California, USA",
  "employeeEstimate": 106,
  "employeeRange": "100 - 250",
  "revenueEstimateUsd": 3550000,
  "revenueRange": "$100K - 5M",
  "totalCompetitors": 25,
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Actual output contains the selected nested sections when Owler provides them.

### Error rows and partial results

An unresolved company is not silently discarded.

The Actor saves a row containing:

- the original input;
- the input type;
- the attempted source URL when known;
- a readable error message;
- the scrape timestamp.

If one company fails and another succeeds, the run succeeds with both rows.

If every requested company fails, the run exits with an error after preserving the diagnostic rows.

### Deduplication and matching

Exact domain inputs are matched against Owler's returned primary domain.

Company names first prefer an exact normalized name or short-name match.

When no exact name match exists, the first public search result is used.

Repeated normalized domain inputs are processed once.

Repeated names and URLs are also removed within their input route.

### How much does it cost to scrape Owler company profiles?

The Actor uses pay-per-event pricing.

A small one-time start event covers run initialization.

A per-company event is charged for each dataset row processed.

The final price shown on the Apify pricing tab is authoritative and can vary by subscription tier.

Control spend with `maxItems` and begin with one to three companies.

The Actor uses HTTP extraction and the tested datacenter proxy route rather than a headless browser or residential proxy.

### Performance and limits

A company normally requires one search request and one profile request.

Explicit Owler profile URLs skip the search request.

The default concurrency is intentionally conservative.

Increase `maxConcurrency` gradually for larger lists, up to 10.

The Actor retries blocked or malformed deliveries with a fresh proxy session.

A run is limited to 1,000 unique company records.

### Export formats

Download dataset results as:

- JSON;
- JSONL;
- CSV;
- Excel;
- XML;
- RSS.

Nested objects are easiest to preserve in JSON or JSONL.

For CSV workflows, use the top-level firmographic fields and flatten nested sections downstream if needed.

### Integrations and automation

#### HubSpot or Salesforce enrichment

Export account website domains, run the Actor, then update company fields using Make, Zapier, n8n, or a custom integration.

#### Slack or email monitoring

Schedule a watchlist run, compare the news and funding sections with the previous dataset, and send newly observed events.

#### Google Sheets

Trigger runs from rows containing company domains and write the normalized result fields back to adjacent columns.

#### Data warehouse

Send dataset items through a webhook or Apify integration into Snowflake, BigQuery, PostgreSQL, or object storage.

#### AI research agents

Expose the Actor through Apify MCP so an agent can fetch current public company context before drafting a brief.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~owler-company-intelligence-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyDomains": ["owler.com", "apple.com"],
    "maxItems": 2
  }'
```

Use the returned run ID to fetch status and dataset items.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/owler-company-intelligence-scraper').call({
  companyDomains: ['owler.com', 'apple.com'],
  maxItems: 2,
  includeCompetitors: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/owler-company-intelligence-scraper').call(run_input={
    'companyNames': ['Microsoft', 'Google'],
    'maxItems': 2,
    'includeNews': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP and AI agents

Connect the Actor to Claude Code through Apify MCP.

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/owler-company-intelligence-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this server to the MCP config used by Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/owler-company-intelligence-scraper"
    }
  }
}
```

Authenticate the Apify MCP server with your Apify account when prompted.

Example prompts:

- “Enrich these five account domains and summarize their employee and revenue ranges.”
- “Build a ranked competitor map for Shopify and Salesforce.”
- “Check the funding and latest news for this startup watchlist.”

Keep `maxItems` explicit in agent workflows to control scope and cost.

### Scheduling recurring company intelligence

Use an Apify schedule for daily, weekly, or monthly refreshes.

Store the current dataset ID after each run.

Compare stable keys such as `companyId`, competitor company IDs, funding round dates, acquisition records, or news titles.

Send only new changes to downstream alerts.

Recurring runs are especially useful for sales territories, market maps, and investment watchlists.

### Data quality tips

- Prefer domains for reliable entity resolution.
- Use full company names instead of short ambiguous words.
- Use explicit Owler URLs when you already know the correct profile.
- Preserve `sourceUrl` and `scrapedAt` in downstream tables.
- Treat revenue and employee numbers as estimates.
- Keep range fields alongside numeric values.
- Review error rows before treating an enrichment batch as complete.

### Troubleshooting

#### Why did a company return an error row?

Owler may not have a public profile, the domain may not match its stored primary domain, or the profile may have been renamed.

Try the exact company name or public Owler URL.

#### Why are some fields missing?

Public profile coverage varies by company.

The Actor omits unavailable values instead of filling them with guesses or `null` placeholders.

#### Why is a competitor list shorter than `totalCompetitors`?

Owler can expose a total count larger than the list embedded in the anonymous public profile.

The Actor returns the competitors actually present in the fetched public state.

#### Can I disable large nested sections?

Yes.

Turn off leadership, competitors, funding, acquisitions, investments, or news independently.

### Responsible use and legality

This Actor extracts data exposed on public Owler company profile pages without requiring an Owler login.

You are responsible for using the data lawfully and for complying with applicable terms, privacy rules, database rights, and regulations.

Do not use the Actor to collect personal data for harassment, discrimination, spam, or unlawful profiling.

Company estimates can be incomplete or outdated.

Verify important business decisions against primary sources.

### Related scrapers

Explore related company and lead-generation tools from [automation-lab](https://apify.com/automation-lab):

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for local business discovery;
- [Yellow Pages Scraper](https://apify.com/automation-lab/yellowpages-scraper) for directory listings;
- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for software-market research;
- [Website Change Monitor](https://apify.com/automation-lab/website-change-monitor) for page-change alerts.

Choose this Actor when Owler's public company profiles and competitor graph are the required source.

### FAQ

#### Does this Actor require an Owler account?

No.

V1 is limited to company intelligence present in anonymously accessible public profile state.

#### Can I combine domains, names, and URLs?

Yes.

All three routes are merged into one run and capped by `maxItems`.

#### Does it use a browser?

No.

It parses server-rendered company state using HTTP requests through Apify Proxy.

#### Does it use residential proxy traffic?

The tested default uses Apify's lower-cost datacenter route.

You can override proxy settings in advanced input if your account or geography requires it.

#### Are revenue and employee values official filings?

Not necessarily.

They are Owler estimates and should be interpreted together with the range and source timestamp.

#### Can I export competitor records separately?

Competitors are nested under each company record to preserve their relationship and rank.

Flatten the array downstream when you need one row per company-competitor edge.

#### What happens when Owler blocks a request?

The Actor retries a bounded number of times with a fresh proxy session.

Persistent failures become typed dataset error rows, and complete extraction failure exits non-zero.

# Actor input Schema

## `companyDomains` (type: `array`):

Website domains to enrich. Exact domain matching makes this the best route for CRM account lists.

## `companyNames` (type: `array`):

Company names to resolve with Owler's public company search.

## `startUrls` (type: `array`):

Explicit public Owler /company/... or /iaApp/...company-profile URLs. Other hosts and page types are rejected.

## `maxItems` (type: `integer`):

Maximum unique company records (including unresolved-input error rows) to save.

## `maxConcurrency` (type: `integer`):

Parallel company lookups. Keep this conservative to reduce blocking.

## `includeLeadership` (type: `boolean`):

Add the public CEO and leadership team details when available.

## `includeCompetitors` (type: `boolean`):

Add Owler's ranked competitor graph with proximity scores and firmographics.

## `includeFunding` (type: `boolean`):

Add funding totals, rounds, investors, and annual funding history.

## `includeAcquisitions` (type: `boolean`):

Add public acquisition history when Owler exposes it for the company.

## `includeInvestments` (type: `boolean`):

Add company investment activity when available in the public profile state.

## `includeNews` (type: `boolean`):

Add recent public news, press, and business-event records from the profile.

## `proxyConfiguration` (type: `object`):

Owler blocks direct requests. The default Apify datacenter proxy is the tested, lowest-cost route.

## Actor input object example

```json
{
  "companyDomains": [
    "owler.com",
    "apple.com"
  ],
  "companyNames": [],
  "startUrls": [],
  "maxItems": 3,
  "maxConcurrency": 3,
  "includeLeadership": true,
  "includeCompetitors": true,
  "includeFunding": true,
  "includeAcquisitions": true,
  "includeInvestments": true,
  "includeNews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companyDomains": [
        "owler.com",
        "apple.com"
    ],
    "companyNames": [],
    "startUrls": [],
    "maxItems": 3,
    "maxConcurrency": 3,
    "includeLeadership": true,
    "includeCompetitors": true,
    "includeFunding": true,
    "includeAcquisitions": true,
    "includeInvestments": true,
    "includeNews": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/owler-company-intelligence-scraper").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 = {
    "companyDomains": [
        "owler.com",
        "apple.com",
    ],
    "companyNames": [],
    "startUrls": [],
    "maxItems": 3,
    "maxConcurrency": 3,
    "includeLeadership": True,
    "includeCompetitors": True,
    "includeFunding": True,
    "includeAcquisitions": True,
    "includeInvestments": True,
    "includeNews": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/owler-company-intelligence-scraper").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 '{
  "companyDomains": [
    "owler.com",
    "apple.com"
  ],
  "companyNames": [],
  "startUrls": [],
  "maxItems": 3,
  "maxConcurrency": 3,
  "includeLeadership": true,
  "includeCompetitors": true,
  "includeFunding": true,
  "includeAcquisitions": true,
  "includeInvestments": true,
  "includeNews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/owler-company-intelligence-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/owler-company-intelligence-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Owler Company Intelligence Scraper",
        "description": "🏢 Enrich company names, domains, or Owler URLs with public firmographics, revenue and employee estimates, leaders, competitors, funding, M&A, and news.",
        "version": "0.1",
        "x-build-id": "UjvyrIfbTzRWGOj0h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~owler-company-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-owler-company-intelligence-scraper",
                "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/automation-lab~owler-company-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-owler-company-intelligence-scraper",
                "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/automation-lab~owler-company-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-owler-company-intelligence-scraper",
                "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": {
                    "companyDomains": {
                        "title": "🌐 Company domains",
                        "type": "array",
                        "description": "Website domains to enrich. Exact domain matching makes this the best route for CRM account lists.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "🏷️ Company names",
                        "type": "array",
                        "description": "Company names to resolve with Owler's public company search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Owler company profile URLs",
                        "type": "array",
                        "description": "Explicit public Owler /company/... or /iaApp/...company-profile URLs. Other hosts and page types are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique company records (including unresolved-input error rows) to save.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel company lookups. Keep this conservative to reduce blocking.",
                        "default": 3
                    },
                    "includeLeadership": {
                        "title": "Include leadership",
                        "type": "boolean",
                        "description": "Add the public CEO and leadership team details when available.",
                        "default": true
                    },
                    "includeCompetitors": {
                        "title": "Include ranked competitors",
                        "type": "boolean",
                        "description": "Add Owler's ranked competitor graph with proximity scores and firmographics.",
                        "default": true
                    },
                    "includeFunding": {
                        "title": "Include funding rounds",
                        "type": "boolean",
                        "description": "Add funding totals, rounds, investors, and annual funding history.",
                        "default": true
                    },
                    "includeAcquisitions": {
                        "title": "Include acquisitions",
                        "type": "boolean",
                        "description": "Add public acquisition history when Owler exposes it for the company.",
                        "default": true
                    },
                    "includeInvestments": {
                        "title": "Include investments",
                        "type": "boolean",
                        "description": "Add company investment activity when available in the public profile state.",
                        "default": true
                    },
                    "includeNews": {
                        "title": "Include recent news",
                        "type": "boolean",
                        "description": "Add recent public news, press, and business-event records from the profile.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy configuration",
                        "type": "object",
                        "description": "Owler blocks direct requests. The default Apify datacenter proxy is the tested, lowest-cost route.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
