# Local Website Verdict for Agency Lead Lists (`natural_lease/local-website-verdict`) Actor

For agencies selling websites or ads to local businesses. Classify each business website URL as a real site, social profile, parked domain, dead page, or thin page. One fetch per URL. $0.00005 to start and $0.004 per saved website verdict. Does not call Google Maps.

- **URL**: https://apify.com/natural_lease/local-website-verdict.md
- **Developed by:** [Nika mint3](https://apify.com/natural_lease) (community)
- **Categories:** Lead generation, SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 website verdicts

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/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

Classify each business website as a **real site**, a **social profile**, a **parked domain**, a **dead page**, or a **thin page**. Paste website URLs, or point at a dataset of them. For every URL the Actor saves one row with the verdict, the final URL, the HTTP status, a short reason, and the page title.

This is a single-page check, not a site crawler. It fetches the given URL once and does not open contact pages, collect email addresses, or call Google Maps.

### Why use Local Business Website Verdict?

A maps lead list often contains a website field that is not a website. It might be a Facebook page, a domain for sale, a dead link, or a one-line placeholder. This Actor answers that question before you spend money on a deeper crawl.

- **One row per URL.** The verdict is `real_site`, `social_only`, `parked`, `dead`, or `thin`.
- **One fetch.** The Actor does not follow links to contact, about, or team pages.
- **No nested Actor.** It does not start Google Maps, Compass, or any other Actor, so there is no second Maps bill.
- **No email scraping.** Page text is used only to judge the page. It is not stored, and addresses are not extracted.
- **Dataset in, dataset out.** Paste URLs or pass a dataset id you already have. Download the verdicts as JSON, CSV, Excel, or HTML, or read them from the Apify API.

You can schedule runs, call the Actor from the API tab, and integrate it with the rest of Apify. Memory is capped at 512 MB because the job is a plain HTTP fetch.

### Related Actors for local agencies

These three Actors are for agencies selling websites or ads to local businesses.

- [No-Website Phone Leads for Local Agencies](https://apify.com/natural_lease/no-website-qualified-leads) — call-ready US Google Maps businesses with no real website. **$0.008** per qualified lead that has a phone. Google Maps Scraper (Compass) is a separate Apify charge.
- [New Maps Openings Monitor for Local Agencies](https://apify.com/natural_lease/google-maps-new-openings-monitor) — likely-new and newly appeared listings. **$0.015** per saved row. The first monitor run learns the city and does not charge for leads. Compass is billed separately.
- [Local Website Verdict for Agency Lead Lists](https://apify.com/natural_lease/local-website-verdict) — this Actor. **$0.004** per saved website verdict. Does not call Google Maps, so there is no Compass charge.

### What data can Local Business Website Verdict extract?

| Field        | Type           | Description                                              |
| ------------ | -------------- | -------------------------------------------------------- |
| `inputUrl`   | string         | The URL you submitted.                                   |
| `verdict`    | string         | `real_site`, `social_only`, `parked`, `dead`, or `thin`. |
| `finalUrl`   | string or null | The URL after redirects.                                 |
| `httpStatus` | number or null | HTTP status of that one fetch.                           |
| `title`      | string or null | The HTML page title.                                     |
| `reason`     | string         | A short explanation of the verdict.                      |

Social hosts (Facebook, Instagram, X, LinkedIn, TikTok, YouTube, and the other profile hosts listed in the code) are `social_only` even when the server returns an error. HTTP statuses outside 200–299, and connection failures, are `dead`. For-sale and domain-parking pages are `parked`. Pages with very little visible text are `thin`. Everything else that returns a normal document is `real_site`.

### How to check a business website

1. Open **Local Business Website Verdict** in Apify Console.
2. Paste up to a few website URLs in **Website URLs**. The prefilled example is three public pages: Wikipedia, example.com, and a Facebook page.
3. Or paste a dataset id in **Dataset of URLs**. Items can use `url`, `website`, or `websiteUrl`.
4. Set the run's max charge. The minimum is about **$0.05**. Leave it there for a cheap test.
5. Start the run and open the dataset. One saved row is one website verdict.

The same input works from the [Apify API](https://docs.apify.com/api/v2). See the input tab for the fields.

### How much will it cost to check websites?

Pricing model: **pay per event**. There is no rental fee and no platform-usage add-on in this price.

| Event               | Title           | Price        | When it is charged                                                                                                           |
| ------------------- | --------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
| `apify-actor-start` | Actor start     | **$0.00005** | Once when the run starts. This Actor allows at most 512 MB, so the start event is charged once, not once per extra gigabyte. |
| `website-verdict`   | Website verdict | **$0.004**   | Once per saved verdict row. This is the primary event.                                                                       |

The Actor charges `website-verdict` only when that row is saved. A URL that produces no row is not charged. Actor start is charged by the platform. The code does not charge it again.

There is **no second Google Maps bill**. This Actor never calls the Google Maps scraper, Compass, or any other Actor. It also does not use Apify Proxy, so there is no proxy line on the run.

Set the minimum allowed max charge (`minimalMaxTotalChargeUsd`) to **$0.05**. A buyer cannot set a cap below that. The prefilled 3-URL example costs about **$0.01205** (one start plus three verdicts), which fits inside that cap.

| Saved rows | Verdict charges | Plus one start |    Total |
| ---------: | --------------: | -------------: | -------: |
|          1 |          $0.004 |       $0.00005 | $0.00405 |
|          3 |          $0.012 |       $0.00005 | $0.01205 |
|         12 |          $0.048 |       $0.00005 | $0.04805 |
|      1,000 |           $4.00 |       $0.00005 | $4.00005 |

When you publish monetization, keep `apify-actor-start` at $0.00005, add `website-verdict` at $0.004 with the title **Website verdict**, and mark `website-verdict` as the primary event. Remove the synthetic `apify-default-dataset-item` event if the console adds it. If that event stays on, each saved row would be billed twice.

### Input

See the input tab for the full form.

- **Website URLs** — one URL per line. The example input is three public URLs so a Store test stays cheap and still returns rows.
- **Dataset of URLs** — an existing dataset id. The Actor only reads items from that dataset. It does not discover URLs by running another Actor.

```json
{
    "startUrls": [
        { "url": "https://www.wikipedia.org" },
        { "url": "https://example.com" },
        { "url": "https://www.facebook.com/facebook" }
    ]
}
```

Only `http` and `https` URLs are fetched. Other schemes are saved as `dead` and are not requested.

### Output

You can download the dataset as JSON, HTML, CSV, or Excel.

```json
[
    {
        "inputUrl": "https://www.wikipedia.org/",
        "finalUrl": "https://www.wikipedia.org/",
        "httpStatus": 200,
        "verdict": "real_site",
        "reason": "Page returned a normal document with enough text to be a real site.",
        "title": "Wikipedia"
    },
    {
        "inputUrl": "https://example.com/",
        "finalUrl": "https://example.com/",
        "httpStatus": 200,
        "verdict": "thin",
        "reason": "Page has very little text.",
        "title": "Example Domain"
    },
    {
        "inputUrl": "https://www.facebook.com/facebook",
        "finalUrl": "https://www.facebook.com/facebook",
        "httpStatus": 200,
        "verdict": "social_only",
        "reason": "Host is a social network (facebook.com).",
        "title": "Facebook"
    }
]
```

The sample titles above are illustrations. A live run stores the title the site actually returns.

### Tips

- Keep the max charge near $0.05 until you trust the rows. Twelve verdicts fit under that cap.
- Run this on a website column you already exported. You do not need a new maps scrape to use it.
- A social link, a parked domain, and a thin placeholder are all saved on purpose. They are the answers, not failures.
- JavaScript-only pages can look thin, because the Actor does not open a browser.

### FAQ, disclaimers, and support

#### Does this call Google Maps?

No. There is no second Maps or Compass bill. The only charges are Actor start ($0.00005) and Website verdict ($0.004 per saved row).

#### Does it scrape emails or contact pages?

No. It does not extract email addresses, phone numbers, or personal profiles, and it does not crawl beyond the one URL you provided.

#### What if the site blocks the fetch?

You still get a row. A connection error or an HTTP error is `dead`, unless the host is a social network, in which case the verdict stays `social_only`.

Our Actors are ethical and do not extract private user data, such as email addresses, gender, or location. They only read the public page at the URL you supplied. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that a page title could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Questions and bugs belong on the Issues tab. Programmatic runs use the API tab.

# Actor input Schema

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

Business website URLs to classify. Each URL is fetched once. The example is three public pages so a Store test stays small.

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

Optional dataset you already have. Each item may use url, website, or websiteUrl. This Actor reads that dataset directly. It does not run Google Maps or any other Actor.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.wikipedia.org"
    },
    {
      "url": "https://example.com"
    },
    {
      "url": "https://www.facebook.com/facebook"
    }
  ],
  "datasetId": ""
}
```

# Actor output Schema

## `verdicts` (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 = {
    "startUrls": [
        {
            "url": "https://www.wikipedia.org"
        },
        {
            "url": "https://example.com"
        },
        {
            "url": "https://www.facebook.com/facebook"
        }
    ],
    "datasetId": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("natural_lease/local-website-verdict").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 = {
    "startUrls": [
        { "url": "https://www.wikipedia.org" },
        { "url": "https://example.com" },
        { "url": "https://www.facebook.com/facebook" },
    ],
    "datasetId": "",
}

# Run the Actor and wait for it to finish
run = client.actor("natural_lease/local-website-verdict").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 '{
  "startUrls": [
    {
      "url": "https://www.wikipedia.org"
    },
    {
      "url": "https://example.com"
    },
    {
      "url": "https://www.facebook.com/facebook"
    }
  ],
  "datasetId": ""
}' |
apify call natural_lease/local-website-verdict --silent --output-dataset

```

## MCP server setup

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

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/7psOpfPEh6oPp3tKJ/builds/fDOesq4NeboF3DYDJ/openapi.json