# Dun & Bradstreet Scraper - Companies, DUNS & Revenue (`haketa/dnb-scraper`) Actor

Search Dun & Bradstreet (dnb.com) and extract company firmographics: name, address, industry, DUNS, revenue, key principals and financials for B2B lead generation and research.

- **URL**: https://apify.com/haketa/dnb-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
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

## Dun & Bradstreet Scraper – Company Data, DUNS, Revenue & Firmographics

**Extract company data from the [Dun & Bradstreet](https://www.dnb.com/) business directory (dnb.com) in minutes.** This Dun & Bradstreet scraper turns any search term into a clean, structured database of companies — complete with **company name, full address, industry, DUNS number, revenue, key principal, parent industry and financial year** — ready for B2B lead generation, sales prospecting, market research and CRM enrichment.

Export everything as **JSON, CSV, Excel, or via API** — no D&B subscription, no manual copy-paste, no coding required.

> 💡 Built for sales teams, lead-gen agencies, market researchers, analysts and founders who need reliable company firmographics and B2B prospecting data at scale.

---

### 🔎 Why scrape Dun & Bradstreet?

Dun & Bradstreet maintains one of the world's largest commercial databases — hundreds of millions of business records, each tied to a unique **D-U-N-S Number**. Its public business directory exposes company profiles with firmographics that are gold for B2B prospecting: industry classification, location, revenue, key decision-makers and corporate hierarchy.

But D&B has no public bulk export, and its directory is a JavaScript app that's painful to copy by hand. This scraper automates the whole process: you give it search terms, it returns hundreds of clean company records you can filter, sort and import anywhere.

**Common reasons people scrape Dun & Bradstreet:**

- Build **targeted B2B lead and prospect lists** by industry and location
- Enrich a **CRM** with company firmographics (industry, address, revenue, DUNS)
- Run **market sizing / TAM analysis** for a sector or region
- Map **corporate hierarchies** (parent vs branch locations)
- Identify **key principals / decision-makers** for outreach
- Power **competitive and industry research**

---

### ✨ What this Dun & Bradstreet scraper does

- ✅ Searches the D&B business directory by **any company name or keyword** (e.g. `software`, `logistics`, `Take-Two`)
- ✅ Returns **hundreds of companies per term** with automatic pagination (de-duplicated)
- ✅ Captures core firmographics — **company name, full address, city, region, ZIP, country, industry, DUNS, parent/branch type**
- ✅ Optional **deep profile mode** adds **revenue, key principal, parent industry, financial year, registered DUNS, number of principals, competitors and similar companies**
- ✅ **Country targeting** — search within US, GB, DE, FR, CA, AU and more
- ✅ Exports to **JSON, CSV, Excel, XML** and integrates with Google Sheets, Make, Zapier, Slack and your own apps
- ✅ **Fast and reliable** — runs against D&B's own directory API, no fragile page rendering

---

### 🎯 Use cases

#### 1. B2B lead generation & sales prospecting
Build targeted prospect lists by searching an industry or keyword and filtering by location. Each company comes with its **industry, full address and profile link** — and with deep mode, **revenue and the key principal** to prioritize and personalize outreach.

#### 2. CRM & data enrichment
Already have company names? Search them and append fresh firmographics — **DUNS number, industry classification, address, revenue and parent industry** — to keep your CRM accurate and your segmentation sharp.

#### 3. Market sizing & TAM analysis
Pull every company in a sector and region to estimate market size, map the competitive landscape, and quantify your total addressable market with real firmographic data rather than guesswork.

#### 4. Corporate hierarchy mapping
The `locationType` field distinguishes **parent companies from branches**, so you can map multi-location enterprises and target the right entity for sales or research.

#### 5. Decision-maker identification
Deep profile mode surfaces the **key principal** and the number of principals on file, helping you find the right person to contact at each company.

#### 6. Competitive & industry intelligence
Combine industry classification, revenue and competitor signals to benchmark companies, track sectors and feed dashboards or analyst models.

#### 7. Risk, credit & supplier research
Firmographics tied to DUNS numbers are the backbone of vendor onboarding, KYB (know-your-business) and supplier due-diligence workflows.

---

### ⚙️ How it works

1. **Enter one or more search terms** — company names or keywords.
2. **Pick a country** and how many companies you want per term.
3. **Optionally enable deep profile mode** for revenue, principals and more.
4. **Run the Actor** — it collects, de-duplicates and structures the data, then makes it available for download or via API.

No login, no D&B subscription, no captcha solving.

#### 🔬 Deep company profiles (optional)

Most directory scrapers stop at the search list. Enable **`scrapeCompanyProfiles`** and this Actor also visits each company's profile to pull:

- **Revenue** — formatted (e.g. `$5.63 billion`) and as a number, with currency and fiscal year
- **Key principal** — the lead executive on file
- **Parent industry**, **registered DUNS**, number of **principals**
- **Competitors** and **similar companies** signals

It's optional because it adds one request per company (slower, more compute). Note: a few fields (exact employee count, phone, incorporation year) are gated by D&B and may come back empty — the scraper returns clean `null` for those rather than garbage.

---

### ✅ Proven results (real run)

A real run for `software` (US) with deep profiles enabled returned **18/18 companies** with:

| Field | Fill rate |
| --- | --- |
| companyName, DUNS, address, city, industry, locationType | 100% |
| revenue & numeric revenue value | 100% |
| key principal (executive) | 100% |
| registered DUNS & number of principals | 100% |

Even when D&B masks the formatted revenue string, the scraper recovers the **numeric revenue** and rebuilds a clean figure (e.g. Koch Software → `$3.17 billion`). Gated fields like exact employee count and phone are returned as `null` rather than placeholder text.

### ⭐ What makes this scraper stand out

- **Deep firmographics, not just listings.** Revenue, key principal, parent industry and DUNS — the fields that actually qualify a B2B account.
- **Clean revenue every time.** When D&B hides the formatted figure, we reconstruct it from the underlying number.
- **No garbage values.** Gated fields become `null`, so your spreadsheet stays tidy.
- **Country targeting + de-duplication** built in for focused, clean prospect lists.

### 🔎 Popular searches & industries

You can search any keyword or company name. Popular B2B sourcing and prospecting examples include:

- **Technology** — software, SaaS, IT services, cybersecurity, semiconductors
- **Industrial** — manufacturing, machinery, automotive, aerospace
- **Logistics** — freight, warehousing, supply chain, distribution
- **Energy** — renewable energy, oil and gas, utilities
- **Healthcare** — medical devices, pharmaceuticals, biotech
- **Finance** — fintech, insurance, investment firms
- **Consumer** — retail, food and beverage, apparel

Pair any term with a `country` code to focus the search on a single market.

### 🔧 Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | ✅ Yes | Company names or keywords to search (e.g. `software`, `logistics`). |
| `country` | string | No | Two-letter country code (US, GB, DE, FR, CA, AU…). Default `US`. |
| `maxItemsPerQuery` | integer | No | Max companies to collect per term. Paginated automatically. Default `50`. |
| `scrapeCompanyProfiles` | boolean | No | Visit each company's profile for revenue, key principal, financials and more. Richer but slower. Default `false`. |
| `proxyConfiguration` | object | No | Apify Proxy settings. US proxy recommended (D&B is geo-aware). |

#### Example input — quick company list

```json
{
    "queries": ["software"],
    "country": "US",
    "maxItemsPerQuery": 200
}
````

#### Example input — deep firmographics

```json
{
    "queries": ["logistics", "renewable energy"],
    "country": "US",
    "maxItemsPerQuery": 100,
    "scrapeCompanyProfiles": true
}
```

#### Example input — search within another country

```json
{
    "queries": ["automotive"],
    "country": "DE",
    "maxItemsPerQuery": 150
}
```

***

### 📤 Output

The Actor stores one row per company. Data can be downloaded as **JSON, CSV, Excel, XML** or pulled via the Apify API.

#### Sample output record (with deep profile)

```json
{
    "companyName": "Take-Two Interactive Software, Inc.",
    "duns": "2d66458a75c9d054a6e33addf02f1573",
    "registeredDuns": "829681063",
    "companyProfileUrl": "https://www.dnb.com/business-directory/company-profiles.take-two_interactive_software_inc...",
    "address": "110 W 44TH St",
    "city": "New York",
    "region": "New York",
    "zipCode": "10036-4011",
    "country": "United States",
    "industryName": "Computer Systems Design and Related Services",
    "locationType": "Parent",
    "revenue": "$5.63 billion",
    "revenueValue": 5633600000,
    "revenueCurrency": "USD",
    "revenueYear": "2025",
    "keyPrincipal": "Strauss Zelnick",
    "parentIndustryName": "Professional, Scientific, and Technical Services",
    "totalPrincipals": "4",
    "competitorsIndustry": "Computer Systems Design and Related Services",
    "similarCompaniesCount": 9,
    "searchTerm": "software",
    "scrapedAt": "2026-05-25T17:00:00.000Z"
}
```

#### Output fields reference

**Core company fields (always present)**

| Field | Description |
| --- | --- |
| `companyName` | Company primary name |
| `duns` | D\&B directory identifier for the company |
| `companyProfileUrl` | Link to the company's D\&B profile |
| `address` / `city` / `region` / `zipCode` / `country` | Full location |
| `countryRegion` | Combined region string |
| `industryName` | Industry classification |
| `locationType` | Parent or branch location |
| `tradeStyleNames` | Trade/DBA names |
| `searchTerm` | The term this record came from |
| `scrapedAt` | Timestamp of extraction |

**Deep profile fields** (only when `scrapeCompanyProfiles` is enabled)

| Field | Description |
| --- | --- |
| `revenue` | Formatted revenue, e.g. `$5.63 billion` |
| `revenueValue` | Revenue as a number |
| `revenueCurrency` | Revenue currency (e.g. USD) |
| `revenueYear` | Fiscal year of the revenue figure |
| `keyPrincipal` | Lead executive on file |
| `parentIndustryName` | Higher-level industry |
| `registeredDuns` | Registered (numeric) DUNS number |
| `totalPrincipals` | Number of principals on file |
| `competitorsIndustry` | Industry used for competitor matching |
| `similarCompaniesCount` | Count of close industry peers |
| `employees` / `phone` / `incorporatedYear` | Returned when D\&B exposes them publicly (otherwise null) |

***

### 🌍 Country coverage

Dun & Bradstreet's directory is global. Set the `country` parameter to focus your search, for example:

- **US** — United States (richest coverage)
- **GB** — United Kingdom
- **DE** — Germany
- **FR** — France
- **CA** — Canada
- **AU** — Australia

…and many more two-letter ISO country codes. US has the deepest data, including the most complete revenue and principal coverage.

***

### 🔌 Integrations

Send your Dun & Bradstreet data anywhere with Apify's built-in integrations and webhooks:

- **Google Sheets** — push company lists straight into a spreadsheet
- **Make (Integromat) & Zapier** — trigger workflows on every run
- **Slack / email** — get notified when new data is ready
- **CRMs & databases** — via API, webhooks or no-code connectors
- **Your own app** — pull results through the Apify API in JSON

***

### ▶️ How to use this Dun & Bradstreet scraper (step by step)

1. Click **Try for free** at the top of this page.
2. In the **Input** tab, add your search terms under `queries`.
3. Set the `country` and `maxItemsPerQuery`, and enable `scrapeCompanyProfiles` if you need revenue and principals.
4. Click **Start** and wait for the run to finish.
5. Open the **Output / Dataset** tab and download your data as **JSON, CSV or Excel**, or copy the API endpoint to pull it programmatically.

You can also **schedule** the Actor to run daily/weekly to keep your company data fresh.

***

### ❓ Frequently asked questions

**Does it include the numeric DUNS number?**
The search result includes a directory identifier, and deep profile mode adds the `registeredDuns` (numeric) when D\&B exposes it publicly.

**Does it include revenue?**
Yes — enable `scrapeCompanyProfiles` and most US companies return a formatted revenue (e.g. `$5.63 billion`) plus a numeric value, currency and fiscal year.

**Why are employee count and phone sometimes empty?**
D\&B gates a few fields (exact employee count, phone, incorporation year) behind its paid products. The scraper detects these and returns clean `null` instead of placeholder text, so your data stays tidy.

**Can I search outside the US?**
Yes — set the `country` parameter to any supported ISO code (GB, DE, FR, CA, AU…). US has the most complete coverage.

**How many companies can I get?**
Results are paginated automatically; set `maxItemsPerQuery` to your target. Broad terms can return many hundreds of companies.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML and RSS — plus direct API access.

**Will I get duplicate companies?**
No. Results are de-duplicated within a run, so overlapping search terms won't create duplicate rows.

**How much does it cost to run?**
You only pay for the results you collect (pay-per-result). The directory API is fast, so runs are economical even at scale.

**Is scraping Dun & Bradstreet legal?**
This Actor collects only publicly available directory data. You are responsible for using the data in compliance with D\&B's terms of use and applicable laws (including data-protection rules such as GDPR where relevant).

**Can I search by company name to find one specific company?**
Yes. Put the exact company name in `queries` (e.g. `Take-Two`) and the directory returns matching companies; enable `scrapeCompanyProfiles` to get full firmographics for each match.

**Does it return the parent company or the branches?**
Both — each record's `locationType` tells you whether it's a `Parent` or a branch location, so you can target the headquarters or map all sites of an enterprise.

**How fresh is the data?**
Every run queries D\&B's directory live, so firmographics reflect what's published at the time you run it. Schedule recurring runs to keep your database current.

**Can I push results straight into my CRM or Google Sheet?**
Yes — use Apify's native integrations (Google Sheets, HubSpot, Make, Zapier) or webhooks to send each run's results wherever you need them, automatically.

**What's the best way to build a large prospect list?**
Use several related keywords (e.g. `software`, `SaaS`, `IT services`) with a country filter and a higher `maxItemsPerQuery`. De-duplication keeps the combined list clean.

***

### 💡 Tips & best practices

- **Use focused search terms.** An industry keyword plus a country returns a clean, relevant set. Combine several terms for broader coverage.
- **Enable deep profiles only when you need revenue/principals** — it's slower and uses more compute, so keep it off for quick list-building.
- **Target the country** with the `country` parameter to avoid mixing markets.
- **Set a realistic `maxItemsPerQuery`.** 100–300 per term suits most prospecting and research projects.
- **Export to a spreadsheet** and sort by `revenueValue` or `industryName` to prioritize the best accounts.
- **Schedule recurring runs** to keep firmographics fresh and catch newly listed companies.
- **De-duplication is automatic** — feel free to add overlapping terms.
- **Sort by `revenueValue`** to instantly surface the largest accounts in a list.
- **Use `locationType`** to separate headquarters (Parent) from branches when planning outreach.
- **Combine industry + country** (e.g. `fintech` in `GB`) for tightly scoped market maps.

***

### 🔗 Built for B2B workflows

This scraper fits naturally into prospecting and research pipelines: pull a company list, enrich it with revenue and key principals, push it to your CRM or spreadsheet, and refresh it on a schedule. Because every record is de-duplicated and exported in open formats (JSON, CSV, Excel), it drops straight into your existing sales, marketing or analytics stack without extra cleanup.

***

### ⚠️ Limitations

- A few firmographic fields (exact employee count, phone, incorporation year) are gated by D\&B and may be empty.
- Revenue and principal coverage is highest for US companies and larger businesses.
- Result volume per term depends on how many companies D\&B lists for that keyword and country.

***

### 🚀 Get started

Click **Try for free**, enter a term like `software` or `logistics`, pick a country, and get a clean list of companies — with industry, address, DUNS and (optionally) revenue and key principals — in minutes. Perfect for **B2B lead generation, sales prospecting, market research and CRM enrichment**.

Have a feature request or question? Open an issue from the Actor's page and we'll help.

# Actor input Schema

## `queries` (type: `array`):

One or more company names or keywords to search the Dun & Bradstreet business directory (e.g. "software", "logistics", "Take-Two").

## `country` (type: `string`):

Two-letter country code to search within, e.g. US, GB, DE, FR, CA, AU. D\&B is geo-aware; US has the richest coverage.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of companies to collect for each search term. Results are paginated automatically (~25 per page).

## `scrapeCompanyProfiles` (type: `boolean`):

Visit each company's profile to add revenue, key principal, parent industry, financial years, competitors and DUNS. Much richer data, but slower (one extra request per company). Some fields (employee count, phone) are gated by D\&B and may be empty.

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

Dun & Bradstreet requires residential proxies (it blocks datacenter IPs) and is geo-aware, so a US residential proxy is recommended for the most complete data.

## Actor input object example

```json
{
  "queries": [
    "software",
    "logistics"
  ],
  "country": "US",
  "maxItemsPerQuery": 25,
  "scrapeCompanyProfiles": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Clean JSON array of every scraped company.

## `companiesCsv` (type: `string`):

The same data as a spreadsheet-ready CSV file.

## `dataset` (type: `string`):

Default dataset of this run for programmatic access.

# 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 = {
    "queries": [
        "software"
    ],
    "country": "US",
    "maxItemsPerQuery": 25,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/dnb-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 = {
    "queries": ["software"],
    "country": "US",
    "maxItemsPerQuery": 25,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/dnb-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 '{
  "queries": [
    "software"
  ],
  "country": "US",
  "maxItemsPerQuery": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call haketa/dnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dun & Bradstreet Scraper - Companies, DUNS & Revenue",
        "description": "Search Dun & Bradstreet (dnb.com) and extract company firmographics: name, address, industry, DUNS, revenue, key principals and financials for B2B lead generation and research.",
        "version": "0.1",
        "x-build-id": "d6iQOmHfUbeRcyH0a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~dnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-dnb-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/haketa~dnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-dnb-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/haketa~dnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-dnb-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Company search terms",
                        "type": "array",
                        "description": "One or more company names or keywords to search the Dun & Bradstreet business directory (e.g. \"software\", \"logistics\", \"Take-Two\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country (ISO alpha-2)",
                        "type": "string",
                        "description": "Two-letter country code to search within, e.g. US, GB, DE, FR, CA, AU. D&B is geo-aware; US has the richest coverage.",
                        "default": "US"
                    },
                    "maxItemsPerQuery": {
                        "title": "Max companies per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of companies to collect for each search term. Results are paginated automatically (~25 per page).",
                        "default": 50
                    },
                    "scrapeCompanyProfiles": {
                        "title": "Scrape full company profiles (richer, slower)",
                        "type": "boolean",
                        "description": "Visit each company's profile to add revenue, key principal, parent industry, financial years, competitors and DUNS. Much richer data, but slower (one extra request per company). Some fields (employee count, phone) are gated by D&B and may be empty.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Dun & Bradstreet requires residential proxies (it blocks datacenter IPs) and is geo-aware, so a US residential proxy is recommended for the most complete data.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
