# Domain Finder DomainScope (`domainscope/domainscope-domain-finder`) Actor

Find company domains by industry, city, and country using the DomainScope categorized-domain corpus.

- **URL**: https://apify.com/domainscope/domainscope-domain-finder.md
- **Developed by:** [Florin Badita](https://apify.com/domainscope) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 domain returneds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## DomainScope Domain Finder — Apify Actor

Find company domains by industry, city, and/or country using DomainScope's
categorized-domain corpus. Wraps `POST /api/v1/domains/search`, which is
public — no DomainScope account or API key required.

Unlike search-engine-scraping approaches (which have to iterate every
profession × city combination as a separate query), DomainScope's filter
engine accepts `industries`/`cities`/`countries` as native arrays with an
`any` (OR) or `all` (AND, default) match mode, so one call covers the
whole combination — "Technology" + "San Francisco" returns Technology
companies that are *in* San Francisco, not either independently.

### Input

See [`.actor/input_schema.json`](.actor/input_schema.json):

- **`industries`**, **`cities`**, **`countries`** — lists to filter on. At
  least one of these (or `searchQuery`) is required. See the DomainScope
  API's `GET /industries`, `/cities`, `/countries` for the full vocabulary
  each accepts.
- **`searchQuery`** — optional free-text filter, combined with the others.
- **`matchMode`** — `"all"` (AND, default) or `"any"` (OR).
- **`maxResults`** — how many domains to fetch (default 200).

### Output

One dataset row per matching domain, shaped like `model.CategoryResult`:
`url`, `category`, `sub_category`, `industry`, `country`, `city`,
`business_model`, `target_market`, `audience_profile`, `content_focus`,
`entity_type`, `summary`.

### The 1,000-record preview cap

DomainScope's search **preview** refuses any page beyond record 1000
(`offset` > 1000 → `limit_exceeded`, "Search preview is limited to 1000
records. Please use the Export feature for bulk data retrieval."). This
Actor pages in batches of 100 (the API's own per-page ceiling) until either
`maxResults` is reached, the 1000-record cap is hit, or results run out.
For volumes beyond that, use DomainScope's own Export feature
(`GET /export/snapshot`) directly against the API.

### Billing

Charges one `domain-returned` event (via `Actor.charge()`) per domain
delivered to the dataset, priced at $3.00 / 1,000 domains on Apify Store.
`Actor.charge()` is a documented no-op outside a pay-per-event-enabled run,
so local development and `apify run` work without any billing setup.

### Local development

```bash
npm install
echo '{"industries": ["Technology"], "cities": ["San Francisco"], "maxResults": 20}' \
  > storage/key_value_stores/default/INPUT.json
npm run start:dev
```

Or: `apify run --input '{"industries": ["Technology"], "cities": ["San Francisco"]}'`

### Deploying

```bash
apify login
apify push
```

# Actor input Schema

## `industries` (type: `array`):

Industries to match, e.g. "Technology", "Finance", "Manufacturing". Combined with cities/countries via AND by default (see matchMode) — e.g. Technology + San Francisco returns Technology companies IN San Francisco, not either. See GET /api/v1/industries on the DomainScope API for the full vocabulary.

## `cities` (type: `array`):

Cities to match, e.g. "San Francisco", "Austin". See GET /api/v1/cities for the full vocabulary.

## `countries` (type: `array`):

Countries to match, e.g. "United States". Optional — narrows further alongside industries/cities. See GET /api/v1/countries for the full vocabulary.

## `searchQuery` (type: `string`):

Optional free-text query matched against domain summaries/content, combined with the other filters.

## `matchMode` (type: `string`):

"all" (AND, default) requires every provided filter to match — e.g. this industry AND this city. "any" (OR) matches domains satisfying at least one filter.

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

Maximum number of domains to fetch. DomainScope's search preview caps out at 1000 records total regardless of this value — use DomainScope's own Export feature for bulk retrieval beyond that.

## `apiKey` (type: `string`):

Not required — POST /domains/search is public. Provide a key only if you have one and want calls attributed to your DomainScope account.

## `apiBaseUrl` (type: `string`):

Base URL of the DomainScope API, including the /api/v1 path. Change only for staging/testing.

## Actor input object example

```json
{
  "industries": [
    "Technology"
  ],
  "cities": [
    "San Francisco"
  ],
  "matchMode": "all",
  "maxResults": 200,
  "apiBaseUrl": "https://domainscope.scrapetheworld.org/api/v1"
}
```

# Actor output Schema

## `matchingDomains` (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 = {
    "industries": [
        "Technology"
    ],
    "cities": [
        "San Francisco"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("domainscope/domainscope-domain-finder").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 = {
    "industries": ["Technology"],
    "cities": ["San Francisco"],
}

# Run the Actor and wait for it to finish
run = client.actor("domainscope/domainscope-domain-finder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "industries": [
    "Technology"
  ],
  "cities": [
    "San Francisco"
  ]
}' |
apify call domainscope/domainscope-domain-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,domainscope/domainscope-domain-finder"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/D0vhS4uAi9VVAjtHa/builds/GPqepkfHzh3Kla4yt/openapi.json