# Company Website Classifier — industry, B2B & ICP fit · $2/1k (`leoworks/company-website-classifier`) Actor

Classify company websites from your crawl: industry, B2B or B2C, reach, ICP fit scoring with tier and reason. Use for company sites; for Google Maps places use leoworks/google-maps-lead-qualifier. datasetId = crawled pages (grouped by site) or pages JSON. ~200 sites/6 s, pay per company.

- **URL**: https://apify.com/leoworks/company-website-classifier.md
- **Developed by:** [Leoworks](https://apify.com/leoworks) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 company classifications

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Company Website Classifier — industry, B2B/B2C & ICP fit

**Part of LeoWorks lead and hiring data tools:** places → leads ([Google Maps Lead Qualifier](https://apify.com/leoworks/google-maps-lead-qualifier)) · company websites → ICP fit ([Company Website Classifier](https://apify.com/leoworks/company-website-classifier)) · job postings → filters ([Job Posting Classifier](https://apify.com/leoworks/job-posting-classifier)).

**For sales teams, lead-gen agencies, B2B marketers and AI agents that already crawl company websites** — and need to classify company websites — what each company does, who it sells to (B2B or B2C) and ICP fit scoring against their ideal customer profile, for $2 per 1,000 websites, with no prompt writing or LLM key.

- **Industry** — 16 groups: software, finance, healthcare, consumer goods & retail, food & hospitality, fitness, manufacturing, distribution & logistics, construction & real estate, professional services, marketing, media, education, energy, government & nonprofit, other
- **Business type** — software / online store / marketplace / in-person services / professional services / manufacturer / distributor / financial services / media / nonprofit & public
- **Customers** — businesses (B2B) / consumers (B2C) / both
- **Reach** — local / regional / national / international
- **ICP fit score (0–100)** — describe the companies you want in plain language (e.g. "Independent dental practices, not chains" or "B2B SaaS companies that sell to ecommerce brands")
- **Your own labels** — up to 10 yes/no criteria (e.g. "offers a free trial", "mentions HIPAA compliance")
- **Tier and reason** — A/B/C/D and a one-line reason per company, for CRM notes
- **Contacts found on the site** — email (the company's own domain first), phone, LinkedIn, Facebook, Instagram, X and YouTube, from the page text, links and schema.org data — no extra charge
- **Pricing, careers and contact pages** — links when the crawl found them
- **No wasted spend** — parked or for-sale domains, Facebook/Linktree-style pages and sites with too little text are skipped and not charged

**Use it to:** turn a crawl of hundreds of websites into a ranked lead list · drop chains, vendors and wrong-fit companies before outreach · segment a market by industry and business model · check which prospects publish pricing · feed labelled companies to a CRM, a dashboard or an AI agent.

**How this differs from our other lead tools:** this one reads **the company's own website** — what it says it does, sells and serves. Our [Google Maps Lead Qualifier](https://apify.com/leoworks/google-maps-lead-qualifier) judges places from their Google Maps listing instead; use both to go from a Maps search to qualified websites.

### How to use

1. Crawl the companies' websites with [Website Content Crawler](https://apify.com/apify/website-content-crawler) (or [RAG Web Browser](https://apify.com/apify/rag-web-browser)) — one start URL per company, **Max crawling depth 1**, about 5 pages per site.
2. Open this Actor, pick that crawl's dataset, and describe your ideal customer in **ICP** (optional).
3. Optional: up to 10 **Custom labels**, **Only websites with an email**, and the start URLs in **Expected websites** to see which sites the crawl missed.
4. Click **Start**. 6 websites (56 pages) take about 3 seconds.
5. Download `COMPANIES.csv` (best fit first, with tier, reason and contacts) or open the **Companies** and **Contacts** views.

#### From a Google Maps search to qualified websites

1. Score places with our [Google Maps Lead Qualifier](https://apify.com/leoworks/google-maps-lead-qualifier). Its `QUALIFIED_WEBSITES` record is a ready Website Content Crawler input: home pages only, no social pages, depth 1, about 6 pages per site.
2. Run Website Content Crawler with it.
3. Run this Actor on the crawl with the same ICP and the start URLs in **Expected websites**. Join the two results on `domain`.

Tested end to end on 2026-10-11: 60 Chicago places → 7 qualified websites → Website Content Crawler (56 pages, $0.008) → this Actor `co17MPWY0GBRXshGL`: 6 companies classified, 1 site the crawl could not read reported as missing.

### Output sample

Real rows from run `b8pJYBhGWLkwiS8GG` (2026-10-10): 211 websites crawled with Website Content Crawler, ICP "Independent dental practices (not chains)", one custom label ("offers emergency or same-day appointments").

| website | fit | industry | business type | customers | reach | custom: same-day |
|---|---|---|---|---|---|---|
| greentreedentalchicago.com | **89** | healthcare | in-person services | consumers | local | **yes (0.94)** |
| themeadowsdentalcare.com | **88** | healthcare | in-person services | consumers | local | **yes (0.98)** |
| kidstoothteam.com | **72** | healthcare | in-person services | consumers | regional | no |
| nexhealth.com *(dental software)* | 36 | software | software | businesses | national | yes (0.52) |
| heartland.com *(dental support organization)* | 23 | healthcare | professional services | businesses | national | no |
| dental360usa.com *(25 clinics)* | 7 | healthcare | in-person services | consumers | regional | yes |
| aspendental.com *(national chain)* | 4 | healthcare | in-person services | consumers | national | yes |
| gorgias.com | 2 | software | software | businesses | international | no |

Each row also has the homepage `url` and `title`, `pagesFound` / `pagesUsed`, the page `language`, `pricingPage` / `careersPage` links, and the probability and confidence of every label.

### Input example

The form default — two pasted homepages, no dataset needed (about $0.004, 2 seconds):

```json
{
  "pages": [
    { "url": "https://acme-analytics.example.com/", "text": "Acme Analytics helps mid-size retailers forecast demand. … plans from $49 per month." },
    { "url": "https://brightsmile-dental.example.org/", "text": "Bright Smile Dental is a family-owned dental practice in South Austin. …" }
  ],
  "icp": "Independent dental practices (not chains)"
}
```

To classify a crawl, pass its dataset instead — pages are grouped by website automatically:

```json
{
  "datasetId": "YOUR_WEBSITE_CONTENT_CRAWLER_DATASET_ID",
  "icp": "B2B software companies that sell to ecommerce brands",
  "customLabels": ["offers a free trial or free plan"]
}
```

**Crawling tips:** start Website Content Crawler with the homepages you want (one per company). **Max crawling depth 1** is enough — the Actor uses the homepage plus up to 4 of the most telling pages (about, products or services, pricing, customers). Its default browser crawler reads sites built with JavaScript; the faster "Raw HTTP" crawler is cheaper but misses some of them (reported as skipped or missing, not charged). Website Content Crawler removes page footers by default, where social links usually are; links in schema.org data are still found.

### Pricing

Pay only for classified websites — no subscription.

| Event | Price | When |
|---|---|---|
| `company-classified` | $0.002 | One website (company) classified from its crawled pages: industry, business type, customer type, reach, ICP fit and any custom labels. Websites with too little text are not charged. |

That is **$2 per 1,000 websites**, whatever the number of pages crawled per site. **First run with the form defaults: about $0.004** (2 websites, 2 seconds).

**Cost examples**

| Websites | Cost |
|---|---|
| 100 | $0.20 |
| 1,000 | $2.00 |
| 10,000 | $20.00 |
| 50,000 | $100.00 |

With the free $5 monthly Apify credit you can classify about **2,500 websites**.

Websites with too little text (under 80 characters, usually sites that need a browser to render) or only bot-check pages are listed with a `skipped` reason and **not charged**. Websites that fail after retries are reported with an `error` field and **not charged**. If you set a maximum cost per run, the Actor stops cleanly when it is reached.

### Works with

| Source on Apify Store | Page URL | Text | Notes |
|---|---|---|---|
| [Website Content Crawler (apify)](https://apify.com/apify/website-content-crawler) | `url` | `text` / `markdown` | title, meta description, language, depth, Open Graph site name and schema.org data used — checked against real output (2026-10-10, 2026-10-11) |
| [RAG Web Browser (apify)](https://apify.com/apify/rag-web-browser) | `metadata.url` / `searchResult.url` | `markdown` | published schema |
| [Contact Details Scraper (vdrmota)](https://apify.com/vdrmota/contact-info-scraper) | `url` | — | its `emails`, `phones`, `linkedIns`, `facebooks`, `instagrams` are merged into the contacts; add its pages to a crawl dataset for the text |
| Other crawlers (`current_url`, `start_url`, `pageTitle`, top-level `description`, `language`, `depth`) | ✓ | `text` / `markdown` / `content` | published schemas |

If none of the items has a page URL the Actor recognises, the run stops with a message instead of finishing with 0 websites. **Also:** the Apify API and JavaScript/Python clients · Apify Schedules · Claude, Cursor and Claude Code through the Apify MCP server (below).

### Call it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/leoworks~company-website-classifier/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"datasetId": "YOUR_CRAWL_DATASET_ID", "icp": "B2B SaaS companies that sell to ecommerce brands"}'
```

JavaScript (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('leoworks/company-website-classifier').call({ datasetId: 'YOUR_CRAWL_DATASET_ID', icp: 'Independent dental practices (not chains)' });
const csv = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('COMPANIES.csv');
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("leoworks/company-website-classifier").call(run_input={"datasetId": "YOUR_CRAWL_DATASET_ID", "icp": "Independent dental practices (not chains)"})
fits = [c for c in client.dataset(run["defaultDatasetId"]).list_items().items if c.get("tier") in ("A", "B")]
```

### Use with Claude, Cursor or Claude Code (MCP)

**Ask your AI agent.** Add the Apify MCP server with this Actor as a tool, then say, for example:

- *"Does this company fit “B2B software companies selling to retailers”? https://acme-analytics.example.com/ — “Acme Analytics helps mid-size retailers forecast demand. Connect Shopify, NetSuite or your POS, and get store-level forecasts every morning. Trusted by 300 retail brands in the US, UK and Canada.”"*
- *"Classify the websites in my Website Content Crawler dataset YOUR_DATASET_ID and keep only the companies that fit “Independent dental practices (not chains)”, with the fit score and reason."*
- *"Tell me the industry, business type, B2B or B2C and reach of this company from its homepage text: “Bright Smile Dental is a family-owned dental practice in South Austin. Dr. Lee and our team offer cleanings, fillings, Invisalign and same-day crowns. New patients welcome.”"*

The agent calls the tool `leoworks--company-website-classifier` and reads the labels with `get-dataset-items`. Replace `YOUR_DATASET_ID` with the ID of your own dataset.

Claude Desktop or Cursor (`mcp.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=leoworks/company-website-classifier",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Claude Code: `claude mcp add --transport http apify "https://mcp.apify.com?tools=leoworks/company-website-classifier" --header "Authorization: Bearer YOUR_APIFY_TOKEN"`. Leave out the header to sign in with OAuth in the browser instead. We verified this setup with the Apify MCP server (v0.17.4) on 2026-10-10: the agent classified a pasted homepage against an ICP in 9 seconds end to end (run `x8Ykm1pLEJkM3f8a9`).

### Output

| Where | What |
|---|---|
| Dataset — view **Companies** | One row per website: company name, fit score, tier, reason, industry, business type, customers, reach, email, phone, pricing and careers pages |
| Dataset — view **Contacts** | Email(s), phone, LinkedIn, Facebook, Instagram, X, YouTube, contact page |
| Dataset — view **Labels with probabilities** | Every label with probability and confidence |
| `COMPANIES.csv` | All classified companies, best ICP fit first, with rank, reason and contacts |
| `REPORT` (JSON) | Label shares across all companies, ICP match rate and the 25 best fits |

#### One row

From run `co17MPWY0GBRXshGL` (2026-10-11, build 0.2.2; `labels` shortened; the company name and contacts are replaced by fictitious values):

```json
{
  "domain": "brightfit-studio.example",
  "companyName": "BrightFit Studio",
  "url": "https://brightfit-studio.example/",
  "title": "BrightFit Studio – Personal Training and Functional Fitness",
  "email": "hello@brightfit-studio.example",
  "phone": "773-555-0142",
  "fitScore": 94,
  "tier": "A",
  "qualified": true,
  "industry": "fitness_wellness",
  "businessType": "in_person_services",
  "customerType": "consumers",
  "reach": "local",
  "reason": "Fits the ICP (94/100, tier A). Fitness & wellness, in-person services. Sells to consumers. Local reach. Contact found: email, phone.",
  "labels": { "icpMatch": { "probability": 0.94, "matched": true } }
}
```

`fitScore` is the ICP match probability × 100 and `qualified` is true from **ICP match threshold** (0.5). Without an ICP, rows have the four company labels only. A narrow, two-part ICP ("SaaS that sells to retailers") gives lower scores than a one-part one — sort by `fitScore` and lower the threshold if too few companies qualify.

#### Summary (REPORT)

Each run also saves a **REPORT** record (Output tab → *Summary by label*) at no extra charge: the count and share of every industry, business type, customer type and reach, the share of websites with a pricing page, and — with an ICP — how many matched plus the 25 best-fitting websites.

```json
{
  "companies": 203,
  "icp": "Independent dental practices (not chains)",
  "icpMatched": 14,
  "topFits": [{ "domain": "smile-dental.example", "fitScore": 96, "industry": "healthcare", "url": "https://www.smile-dental.example/" }],
  "pricingPageShare": 0.118,
  "industry": { "healthcare": { "count": 33, "share": 0.163 }, "software_internet": { "count": 31, "share": 0.153 } }
}
```

### Accuracy

Measured on 179 hand-labelled English company websites crawled with Website Content Crawler (2026-10-10): 62 employers from a sample of US job postings, 37 local businesses from Google Maps (dentists, gyms, restaurants) and 80 companies chosen to cover SaaS, online stores, agencies, manufacturers, distributors, finance, media and nonprofits. Each website was also paired with two of ten ICPs — its own kind and a near miss (e.g. a dental chain or dental software against "independent dental practices"). The questions were adjusted on one part, then checked once on a separate part that was not used for adjusting.

| Set | Websites | Industry | Business type | Customers | Reach | All four right | ICP pairs | ICP fit right |
|---|---|---|---|---|---|---|---|---|
| **Check set — not used for adjusting** | 109 | **99%** | **98%** | **98%** | **97%** | **93%** | 218 | **99%** |
| Adjusting set | 70 | 100% | 100% | 100% | 96% | 96% | 140 | 99% |

A label counts as right when it matches the hand label or an alternative noted for companies that fit two answers (e.g. Stripe is both *software* and *financial services*; a company in the US and Canada is *national* or *international*). ICP pairs that a careful reader could answer either way (e.g. an insurer against "banks, lenders and fintech") count as right either way — 24 of the 218 check pairs. Of the check-set websites that truly fit their ICP, 97% were found. Websites with only a few lines of text (often sites that need a browser crawler) give the model little to go on — check those rows. Automated labels can be wrong; check samples before making big decisions.

### Limits

| Item | Limit |
|---|---|
| Pages used per website | Homepage (first 3,000 characters) + up to 4 more pages (1,500 characters each) |
| ICP | Up to 1,000 characters |
| Custom labels | Up to 10, each up to 200 characters |
| Dataset size | Any number of pages; all pages are read first, then each website is classified once |
| Language | English (measured). Other languages are accepted and usually work, but accuracy has not been measured — treat them as **beta** |
| Speed | About 200 websites in 6 seconds |
| Contacts | Up to 5 of each kind per website, from crawled pages only — sites that hide them in images or scripts give none |
| Data | Only page URLs, titles, meta descriptions and page text are sent for classification. Contact details are read from your crawl by code and never sent to the AI; use them in line with privacy and anti-spam law |

### FAQ

**Which AI makes the judgments?** Jev, TypeSafe's decision model (version `jev-1.13.0`, pinned). Jev answers each label with a calibrated probability instead of generated text, so a fit score of 80 means the same thing across websites; the same site can move a few points between runs.

**Does it crawl websites?** No. It classifies pages you already crawled — run Website Content Crawler first (see **Works with**) or paste page text.

**How is this different from tools that take a list of domains?** Those crawl each domain themselves and charge for it. This one uses a crawl you already have (or a cheap one you run with depth 1), so you pay $2 per 1,000 companies for the judgment — and the crawl can be reused for other things. Add Website Content Crawler's cost to compare (about $0.008 for 7 sites with the Raw HTTP crawler in our test).

**Which websites are skipped and not charged?** Parked, for-sale or "coming soon" domains, pages on social or directory hosts (facebook.com/yourshop, linktr.ee), sites whose crawl has too little text, and — with **Only websites with an email** — sites without an email.

**Why is a website counted once if I crawled 50 of its pages?** You pay per company, not per page. The Actor picks the pages that say most about the company (homepage, about, products or services, pricing, customers).

### Disclaimer

> Independent tool — not affiliated with, endorsed by or sponsored by the companies shown or by the author of the crawler listed above. Company names are used only as examples of public websites.

### Reviews and support

If this Actor saved you time, a short review on Apify Store helps others find it. Questions or a dataset whose fields are not detected? Open an issue in the **Issues** tab — we answer within a day.

### Changelog

See the Changelog tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/leoworks/company-website-classifier/changelog.md

# Actor input Schema

## `datasetId` (type: `string`):

An Apify dataset of crawled website pages — for example the output of Website Content Crawler. Pages are grouped by website (host without “www.”), and each website is classified once. Use this OR “Pages”.

## `pages` (type: `array`):

Pages pasted as JSON objects with “url” and “text” (optionally “title”). Pages with the same host are treated as one company. Use this OR “Crawled pages dataset”.

## `icp` (type: `string`):

Describe the companies you want as leads in plain language, e.g. “B2B software companies selling to retailers” or “Independent dental practices (not chains)”. Each website gets a fit score (0–100). Leave empty to get only the company labels.

## `customLabels` (type: `array`):

Up to 10 extra yes/no checks (each up to 200 characters) in plain language, e.g. “offers a free trial”, “mentions HIPAA compliance”, “has offices in Europe”. Each gets a probability.

## `requireEmail` (type: `boolean`):

Skip (not charged) websites where no email address was found on the crawled pages.

## `expectedWebsites` (type: `array`):

The websites you asked the crawler to visit (its start URLs). Any that have no crawled page are listed in the output as missing (not charged), so you know which ones to crawl again with a browser crawler.

## `matchThreshold` (type: `number`):

Minimum fit probability (0–1) for a website to be marked as qualified.

## `maxCompanies` (type: `integer`):

Classify at most this many websites (0 = all).

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

Websites classified in parallel.

## `healthCheck` (type: `boolean`):

Internal: fail the run when results look degraded (used by the developer's scheduled checks).

## Actor input object example

```json
{
  "pages": [
    {
      "url": "https://acme-analytics.example.com/",
      "title": "Acme Analytics — demand forecasting for retailers",
      "text": "Acme Analytics helps mid-size retailers forecast demand. Connect Shopify, NetSuite or your POS, and get store-level forecasts every morning. Trusted by 300 retail brands in the US, UK and Canada. Start a 14-day free trial — plans from $49 per month."
    },
    {
      "url": "https://brightsmile-dental.example.org/",
      "title": "Bright Smile Dental — family dentist in Austin, TX",
      "text": "Bright Smile Dental is a family-owned dental practice in South Austin. Dr. Lee and our team offer cleanings, fillings, Invisalign and same-day crowns. New patients welcome — call or book online. We accept most PPO insurance plans."
    }
  ],
  "icp": "Independent dental practices (not chains)",
  "customLabels": [],
  "requireEmail": false,
  "expectedWebsites": [],
  "matchThreshold": 0.5,
  "maxCompanies": 0,
  "maxConcurrency": 10,
  "healthCheck": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `report` (type: `string`):

No description

## `companiesCsv` (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 = {
    "pages": [
        {
            "url": "https://acme-analytics.example.com/",
            "title": "Acme Analytics — demand forecasting for retailers",
            "text": "Acme Analytics helps mid-size retailers forecast demand. Connect Shopify, NetSuite or your POS, and get store-level forecasts every morning. Trusted by 300 retail brands in the US, UK and Canada. Start a 14-day free trial — plans from $49 per month."
        },
        {
            "url": "https://brightsmile-dental.example.org/",
            "title": "Bright Smile Dental — family dentist in Austin, TX",
            "text": "Bright Smile Dental is a family-owned dental practice in South Austin. Dr. Lee and our team offer cleanings, fillings, Invisalign and same-day crowns. New patients welcome — call or book online. We accept most PPO insurance plans."
        }
    ],
    "icp": "Independent dental practices (not chains)"
};

// Run the Actor and wait for it to finish
const run = await client.actor("leoworks/company-website-classifier").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 = {
    "pages": [
        {
            "url": "https://acme-analytics.example.com/",
            "title": "Acme Analytics — demand forecasting for retailers",
            "text": "Acme Analytics helps mid-size retailers forecast demand. Connect Shopify, NetSuite or your POS, and get store-level forecasts every morning. Trusted by 300 retail brands in the US, UK and Canada. Start a 14-day free trial — plans from $49 per month.",
        },
        {
            "url": "https://brightsmile-dental.example.org/",
            "title": "Bright Smile Dental — family dentist in Austin, TX",
            "text": "Bright Smile Dental is a family-owned dental practice in South Austin. Dr. Lee and our team offer cleanings, fillings, Invisalign and same-day crowns. New patients welcome — call or book online. We accept most PPO insurance plans.",
        },
    ],
    "icp": "Independent dental practices (not chains)",
}

# Run the Actor and wait for it to finish
run = client.actor("leoworks/company-website-classifier").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 '{
  "pages": [
    {
      "url": "https://acme-analytics.example.com/",
      "title": "Acme Analytics — demand forecasting for retailers",
      "text": "Acme Analytics helps mid-size retailers forecast demand. Connect Shopify, NetSuite or your POS, and get store-level forecasts every morning. Trusted by 300 retail brands in the US, UK and Canada. Start a 14-day free trial — plans from $49 per month."
    },
    {
      "url": "https://brightsmile-dental.example.org/",
      "title": "Bright Smile Dental — family dentist in Austin, TX",
      "text": "Bright Smile Dental is a family-owned dental practice in South Austin. Dr. Lee and our team offer cleanings, fillings, Invisalign and same-day crowns. New patients welcome — call or book online. We accept most PPO insurance plans."
    }
  ],
  "icp": "Independent dental practices (not chains)"
}' |
apify call leoworks/company-website-classifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leoworks/company-website-classifier"
        }
    }
}
```

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/W2JedRrKnFgoyzEWv/builds/ydRtYyjjchl7Ytrex/openapi.json