# Website Audit Lead Finder — Web Design Leads (`jurassic_jove/website-audit-leads`) Actor

Finds businesses with bad websites and turns them into qualified leads. Bulk-checks any list of sites for missing SSL, broken mobile layout, slow load times and outdated tech, then scores each 0-100 with a plain-English issue list. Built for web designers and SEO agencies.

- **URL**: https://apify.com/jurassic\_jove/website-audit-leads.md
- **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 website audited & scoreds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Website Health Lead Qualifier — Find Businesses With Bad Websites (+ Contact Info)

**The best web design lead is a business whose website is visibly broken.** This Actor audits any list of business websites for missing HTTPS, broken mobile layouts, slow load times, dead links and outdated tech, scores each site **0–100**, and hands back the failing ones as qualified leads — each with a **plain-English list of what's wrong** and the **contact emails** to reach them.

> Also searched as: *find businesses with bad websites*, *web design leads*, *website audit lead generation*, *outdated website finder*, *find clients who need a new website*, *bulk website checker*.

Other tools tell you a website's score. This one tells you **which businesses to call — and exactly what to say.**

---

### Why bad websites are the easiest web design clients to close

Cold outreach fails because it opens with a guess. This Actor opens with a **diagnosis the prospect can verify in ten seconds on their own phone.**

- 🔍 **The audit IS the pitch.** Every issue comes back written for the business owner, not for a developer: *"Your pages run off the edge of a phone screen, forcing visitors to scroll sideways to read your content."* Paste it straight into the email.
- 🎯 **A transparent 0–100 health score.** Rank a hopeless 1998 site above a merely dated one, so your team calls the biggest opportunities first. The formula is published below — no black box.
- ✉️ **Contacts in the same visit.** Emails, phone numbers and social links are extracted during the *same* browser visit that runs the audit. One visit, two jobs — and no extra charge.
- 💀 **Dead websites are found, not skipped.** A domain that no longer resolves, an expired certificate, a 500 error — these are reported as leads, not silently dropped. They are the strongest pitch there is.
- 🚫 **No invented findings.** A check that could not run is reported as *unmeasured*, never as a failure. You will never be handed a "problem" that doesn't exist in front of a prospect.

#### Who it's for

| You are… | You get… |
|---|---|
| A **web designer / freelancer** | Businesses whose sites fail on mobile — with the evidence attached. |
| A **web development shop** | Sites on discontinued builders and dead tech that need a rebuild, not a patch. |
| An **SEO / CRO agency** | Sites missing titles, meta descriptions, structured data — or accidentally hidden from Google entirely. |
| A **hosting / care-plan seller** | Sites with 3-second server responses and expired certificates. |

---

### How it works

1. **Get your targets.** Either discover businesses by category and location on Google Maps, or feed in a list you already have (Apify dataset, CSV, or pasted records).
2. **Visit each site once** with a real mobile browser at a 390 px phone viewport — the same width an iPhone uses.
3. **Measure everything in that one visit**: certificate validity, mobile rendering, page weight and speed, footer copyright year, dead links, platform and legacy tech, SEO tags, and whether a customer can even find a phone number.
4. **Score 0–100** with a published weighted formula and generate the plain-English issue list.
5. **Deliver** one row per business — optionally filtered to only the sites below your score threshold, which are your actual leads.

---

### Two ways to feed it

#### Discovery mode — find the businesses for me

```json
{
  "searchTerms": ["plumbers"],
  "location": "Tampa, FL",
  "maxSites": 100,
  "onlyBelowScore": 60,
  "extractEmails": true
}
````

Finds plumbers in Tampa that publicly list a website, audits every one, and returns **only the sites scoring below 60** — the businesses whose websites are actively costing them customers.

#### List mode — I already have the businesses

```json
{
  "datasetIds": ["aBcD1234efGh5678"],
  "csvUrls": ["https://example.com/my-leads.csv"],
  "inlineRecords": [
    { "businessName": "Acme Plumbing", "website": "acmeplumbing.com" }
  ],
  "maxSites": 250,
  "onlyBelowScore": 75
}
```

Mix all three sources freely — they are merged and de-duplicated by domain, so the same business is never audited (or charged for) twice. The website column is **auto-detected** (`website`, `websiteUrl`, `url`, `domain`, `site`, `homepage`, `web`), or name it yourself with `websiteField`.

***

### What you get back

One vivid example — a real-shaped record for a fictional business:

```json
{
  "businessName": "Bayside Plumbing & Heating",
  "website": "http://baysideplumbing.com",
  "status": "ok",
  "healthScore": 31,
  "grade": "F",
  "isLead": true,
  "isPriorityLead": true,
  "confidence": "high",
  "issueSummary": "no HTTPS, not mobile-ready, breaks on phones (+7 more)",
  "majorIssueCount": 5,
  "minorIssueCount": 5,
  "issues": [
    {
      "check": "ssl-missing",
      "category": "security",
      "severity": "major",
      "points": 25,
      "plainEnglish": "Your site doesn't use HTTPS — browsers show visitors a 'Not Secure' warning, and many will leave before the page loads. It also pushes you down in Google's search results."
    },
    {
      "check": "viewport-missing",
      "category": "mobile",
      "severity": "major",
      "points": 12,
      "evidence": "no viewport tag",
      "plainEnglish": "Your site isn't set up for phones, so it loads at desktop size and visitors have to pinch and zoom to read anything. Most of your customers are searching on a phone."
    },
    {
      "check": "copyright-stale-severe",
      "category": "freshness",
      "severity": "major",
      "points": 10,
      "evidence": "© 2016",
      "plainEnglish": "The copyright date at the bottom of your site is several years out of date, which makes visitors wonder whether you're still in business. It's one of the first things people check."
    }
  ],
  "ssl": "none",
  "mobileFriendly": false,
  "ttfbMs": 1450,
  "pageWeightMb": 6.2,
  "requestCount": 41,
  "copyrightYear": 2016,
  "platformDetected": null,
  "emails": ["info@baysideplumbing.com", "mike@baysideplumbing.com"],
  "primaryEmail": "info@baysideplumbing.com",
  "phone": "(555) 214-8890",
  "socialLinks": { "facebook": "https://facebook.com/baysideplumbing" },
  "source": "discovery"
}
```

Every run also writes a summary to the key-value store (`OUTPUT`) and as a final dataset row: sites audited, average score, grade distribution, the most common issues across the whole batch, contactability rate, unreachable count and runtime.

***

### The health score, explained (no black box)

Every site starts at **100** and loses points for each problem found. Weights track **what a designer can actually pitch and get paid for**, not what an engineer finds interesting.

| Category | Max deduction | The heaviest checks in it |
|---|---|---|
| **Security & trust** | 25 | No HTTPS (25) · invalid certificate (20) · mixed content (8) |
| **Mobile experience** | 25 | Not phone-ready (12) · content overflows the screen (10) · cramped tap targets (5) · unreadable text (4) · zoom blocked (4) |
| **Freshness & tech debt** | 25 | Flash (10) · stale copyright (10) · broken links (8) · table layout (8) · outdated CMS (8) · quirks mode (6) · ancient jQuery (5) |
| **Performance** | 20 | Slow server response (8) · very heavy pages (8) · oversized images (5) · too many requests (4) |
| **SEO hygiene** | 20 | Hidden from Google (12) · no page title (8) · placeholder title (6) · no meta description (4) |
| **Contactability** | 15 | No phone number (7) · no contact page (7) · no email or form (4) · no address (3) |

**Why the caps.** Eight cheap SEO checks failing is *one* problem — "nobody did any SEO" — not eight. Capping each category stops correlated checks from drowning out a genuine "no HTTPS **and** not mobile" rebuild candidate. The final score therefore answers the question that actually matters: *how many independent things are wrong, and how badly?*

#### Grades

| Grade | Score | What it means for you |
|---|---|---|
| **A** | 90–100 | Healthy. Not a lead. |
| **B** | 75–89 | Minor issues. Weak lead — fix-list or retainer at best. |
| **C** | 60–74 | **Warm lead.** Problems in at least two categories. |
| **D** | 40–59 | **Strong lead.** Structurally broken; a redesign is obvious. |
| **F** | 0–39 | **Priority lead.** The site is actively costing them customers. |

Reaching grade C requires ~40 points of damage, which is impossible from a single category — so **every C-or-below site has verified problems in at least two independent areas.** That is what makes the pitch hard to dismiss.

#### When we don't know, we say so

A check that could not be completed is recorded as **unmeasured** and deducts nothing. If too much of the audit failed to run, the site is returned with `grade: null` and `confidence: "low"` rather than a flattering score. A partially-audited site that scores 92 is not an A — it's ungraded. This is deliberate: one fabricated finding in front of a prospect costs you the relationship, while a missed one only costs you a lead.

***

### Pricing

Pay per event. No subscription.

| Event | Price | When it fires |
|---|---|---|
| **Website audited & scored** | **$0.02** | Once per site actually reached over the network |
| **AI outreach pitch** | **$0.012** | Only when the AI pitch is enabled *and* really produced one |
| Actor start | $0.00005 | Once per run |

**A realistic run:** 100 sites audited with contact extraction = **$2.00**. Add AI pitches for the 40 that qualify as leads = **$2.48 total.**

**What is never charged:**

- Rows with no website, malformed URLs, and duplicates you supplied twice.
- Anything skipped because your budget cap was reached.
- A pitch that fell back to the built-in template because the AI engine was unavailable.

**What *is* charged, and why:** a site that is down, times out, returns a 500 or has an expired certificate **is charged** — the work was done and a broken website is the most valuable finding this Actor produces. Sites filtered out by `onlyBelowScore` are **also charged**, because they were fully audited; the filter controls what lands in your dataset, not what work was performed.

Set `maxTotalChargeUsd` to cap a run's spend. It stops cleanly at the limit and tells you what it didn't reach — it never silently drops records.

***

### Works perfectly with the rest of the suite

This Actor turns a raw business list into a ranked pitch list. Chain it with the rest of the stack:

1. **[Google Maps Lead Generator Pro](https://apify.com/jurassic_jove/google-maps-lead-generator-pro)** — find local businesses and their websites.
2. **Website Health Lead Qualifier** *(you are here)* — audit every site, keep the ones that need help.
3. **[Lead List Deduplicator & Merger](https://apify.com/jurassic_jove/lead-deduplicator-merger)** — merge with your other sources and de-duplicate before you spend on verification.
4. **[Email Verifier & Enricher Pro](https://apify.com/jurassic_jove/email-verifier-enricher-pro)** — validate every address so your outreach actually lands.
5. **[Icebreaker Generator](https://apify.com/jurassic_jove/icebreaker-generator)** — turn each record into a personalized opener.

***

### Honest limitations

Read this before you rely on a number.

- **This is a single-visit heuristic audit, not a full Lighthouse report.** It measures the homepage (plus up to two contact pages) in one real browser visit. It does not compute Core Web Vitals, does not crawl your prospect's whole site, and is not a substitute for a manual review before you quote a price.
- **Scores are indicative, meant for ranking.** They are excellent at sorting 500 businesses into "call these first". Treat a single site's exact number as a starting point, not a verdict.
- **Load times reflect our network, not your prospect's customers.** The run measures from a datacenter proxy. A real visitor on mobile data will usually be slower.
- **Some sites block automated visits.** Bot-protection walls are reported honestly as `status: "blocked"` rather than being scored as healthy — but we can't audit what we can't see.
- **Platform detection is fingerprint-based.** An unknown platform is reported as *unknown*, never as *obsolete*.
- **Discovery mode delegates to a Google Maps Actor**, which runs as a separate Apify Actor call and is billed by that Actor. Feeding in your own list avoids that entirely.

***

### FAQ

**How do I find businesses with bad websites?**
Run this Actor in discovery mode with a business category and a location — for example `"plumbers"` and `"Tampa, FL"` — and set `onlyBelowScore` to 60. You get back every plumber in Tampa whose website scores below 60, with the specific problems listed in plain English and their contact emails attached.

**How do web designers find clients?**
The highest-converting approach is a specific, verifiable observation about the prospect's current site. That is exactly what this Actor produces at scale: instead of "we build websites", you open with "your site isn't secure and doesn't work on phones — here's what visitors see."

**How do I check if a website is mobile friendly in bulk?**
Feed a list of URLs in list mode. Each site is rendered at a real 390 px phone viewport and checked for a viewport tag, horizontal overflow, tap-target crowding and unreadable text — the four things that actually break a site on a phone.

**How much does it cost to check 1,000 websites?**
$20.00 — 1,000 × $0.02. Contact extraction is included at no extra cost because it happens during the same visit.

**Is this the same as a Lighthouse or PageSpeed checker?**
No, and deliberately so. Those tools grade one site for a developer. This one screens hundreds of businesses for a salesperson, and every finding is written as something you can say to a business owner. It is a lead-qualification tool that happens to audit, not an audit tool.

**What happens if a website is down or blocks the check?**
It is returned as a row with a clear status (`dns_error`, `timeout`, `http_error`, `ssl_error`, `blocked`) and always passes your lead filter. A dead website is the strongest sales opening there is — it just needs a different script.

**How accurate is the score?**
The measurements are deterministic and reproducible: the same site scores the same twice. The weighting is a commercial judgment about what sells, published in full above so you can decide whether you agree. Where a check can't be completed it is excluded rather than guessed.

**Can I export the leads to CSV or Google Sheets?**
Yes — results can be exported as CSV, JSON, Excel or HTML from the run's dataset, or pulled through the Apify API.

**Do I need proxies?**
No — proxies are off by default and that is deliberate. Business websites are visited once each and do not need one, and routing through a proxy distorts the load-time and page-weight numbers this Actor exists to measure. Residential proxies also bill per GB, and the audit downloads images on purpose in order to weigh the page. Switch a proxy on only if sites start coming back as `blocked`.

# Actor input Schema

## `searchTerms` (type: `array`):

Discovery mode. Business categories to look up on Google Maps, e.g. "plumbers", "dentists", "law firms". Combined with the Location below. Only businesses that publicly list a website are audited. Leave empty if you are supplying your own list further down.

## `location` (type: `string`):

City, region or country for the Google Maps search, e.g. "Tampa, FL". Only used with the business categories above.

## `datasetIds` (type: `array`):

List mode. IDs of datasets produced by previous Actor runs (Google Maps Lead Generator Pro, Business Finder, your own scrapers). All items are fetched with pagination. Invalid IDs are skipped with a warning, never a crash.

## `csvUrls` (type: `array`):

List mode. Public URLs to CSV files (a key-value store download link works). The parser tolerates a BOM, comma/semicolon/tab/pipe delimiters and quoted fields. Malformed rows are skipped and counted, never crashing the run.

## `inlineRecords` (type: `array`):

List mode. Records pasted directly as a JSON array. Accepts objects or bare URL strings. The example below shows the format — replace it with your own records or clear it.

## `websiteField` (type: `string`):

Which field in your records holds the website. Leave empty to auto-detect — the Actor looks for website, websiteUrl, url, domain, site, homepage or web (case-insensitive) and also accepts bare URL strings.

## `maxSites` (type: `integer`):

Hard cap on billable audits. Each site actually reached and evaluated costs $0.02. The Console pre-fills 10 for a cheap trial run (~$0.20); the default for API runs is 100 (~$2.00).

## `maxTotalChargeUsd` (type: `integer`):

Hard spend cap for the whole run. The Actor stops cleanly the moment this budget is reached and reports what it did not process — it never silently drops records.

## `onlyBelowScore` (type: `integer`):

Optional lead filter. Only sites scoring BELOW this number are written to the dataset — those are your actual leads. Leave empty to output every audited site. Note: filtered-out sites were still fully audited, so they are still charged; unreachable sites always pass the filter (a dead website is the strongest pitch there is).

## `extractEmails` (type: `boolean`):

Collect emails, phone numbers and social links during the SAME browser visit that runs the audit (plus up to 2 contact/about pages). One visit, two jobs — this adds no extra charge.

## `aiPitchSummary` (type: `boolean`):

Write a 2-sentence, ready-to-send pitch angle for each lead, referencing that site's specific problems. Charged $0.012 per pitch generated. Off by default.

## `pitchTone` (type: `string`):

Only used when the AI pitch is enabled.

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

How many sites are audited in parallel. Higher is faster but heavier — above 5, raise the run's memory to 4096 MB.

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

OFF by default, on purpose. Ordinary business websites are visited once each and do not need a proxy, and routing through one measurably distorts the very numbers this Actor sells — load time and page weight. A residential proxy also bills per GB, and because the audit deliberately downloads images to weigh the page, that gets expensive fast. Turn a proxy on only if you see sites coming back as "blocked".

## Actor input object example

```json
{
  "searchTerms": [
    "plumbers"
  ],
  "location": "Tampa, FL",
  "datasetIds": [],
  "csvUrls": [],
  "inlineRecords": [
    {
      "businessName": "Acme Plumbing",
      "website": "acmeplumbing.com"
    },
    {
      "businessName": "Bluebird Bakery",
      "website": "https://www.bluebirdbakery.co"
    }
  ],
  "maxSites": 10,
  "maxTotalChargeUsd": 10,
  "extractEmails": true,
  "aiPitchSummary": false,
  "pitchTone": "consultative",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchTerms": [
        "plumbers"
    ],
    "location": "Tampa, FL",
    "datasetIds": [],
    "csvUrls": [],
    "inlineRecords": [
        {
            "businessName": "Acme Plumbing",
            "website": "acmeplumbing.com"
        },
        {
            "businessName": "Bluebird Bakery",
            "website": "https://www.bluebirdbakery.co"
        }
    ],
    "maxSites": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/website-audit-leads").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 = {
    "searchTerms": ["plumbers"],
    "location": "Tampa, FL",
    "datasetIds": [],
    "csvUrls": [],
    "inlineRecords": [
        {
            "businessName": "Acme Plumbing",
            "website": "acmeplumbing.com",
        },
        {
            "businessName": "Bluebird Bakery",
            "website": "https://www.bluebirdbakery.co",
        },
    ],
    "maxSites": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/website-audit-leads").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 '{
  "searchTerms": [
    "plumbers"
  ],
  "location": "Tampa, FL",
  "datasetIds": [],
  "csvUrls": [],
  "inlineRecords": [
    {
      "businessName": "Acme Plumbing",
      "website": "acmeplumbing.com"
    },
    {
      "businessName": "Bluebird Bakery",
      "website": "https://www.bluebirdbakery.co"
    }
  ],
  "maxSites": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jurassic_jove/website-audit-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Audit Lead Finder — Web Design Leads",
        "description": "Finds businesses with bad websites and turns them into qualified leads. Bulk-checks any list of sites for missing SSL, broken mobile layout, slow load times and outdated tech, then scores each 0-100 with a plain-English issue list. Built for web designers and SEO agencies.",
        "version": "0.1",
        "x-build-id": "OlhVlFsZgdb0E5lk4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~website-audit-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-website-audit-leads",
                "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/jurassic_jove~website-audit-leads/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-website-audit-leads",
                "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/jurassic_jove~website-audit-leads/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-website-audit-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Business categories to discover",
                        "type": "array",
                        "description": "Discovery mode. Business categories to look up on Google Maps, e.g. \"plumbers\", \"dentists\", \"law firms\". Combined with the Location below. Only businesses that publicly list a website are audited. Leave empty if you are supplying your own list further down.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region or country for the Google Maps search, e.g. \"Tampa, FL\". Only used with the business categories above."
                    },
                    "datasetIds": {
                        "title": "Or: Apify dataset IDs",
                        "type": "array",
                        "description": "List mode. IDs of datasets produced by previous Actor runs (Google Maps Lead Generator Pro, Business Finder, your own scrapers). All items are fetched with pagination. Invalid IDs are skipped with a warning, never a crash.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "csvUrls": {
                        "title": "Or: CSV file URLs",
                        "type": "array",
                        "description": "List mode. Public URLs to CSV files (a key-value store download link works). The parser tolerates a BOM, comma/semicolon/tab/pipe delimiters and quoted fields. Malformed rows are skipped and counted, never crashing the run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "inlineRecords": {
                        "title": "Or: inline records",
                        "type": "array",
                        "description": "List mode. Records pasted directly as a JSON array. Accepts objects or bare URL strings. The example below shows the format — replace it with your own records or clear it."
                    },
                    "websiteField": {
                        "title": "Website field name",
                        "type": "string",
                        "description": "Which field in your records holds the website. Leave empty to auto-detect — the Actor looks for website, websiteUrl, url, domain, site, homepage or web (case-insensitive) and also accepts bare URL strings."
                    },
                    "maxSites": {
                        "title": "Maximum sites to audit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on billable audits. Each site actually reached and evaluated costs $0.02. The Console pre-fills 10 for a cheap trial run (~$0.20); the default for API runs is 100 (~$2.00).",
                        "default": 100
                    },
                    "maxTotalChargeUsd": {
                        "title": "Maximum total charge (USD)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard spend cap for the whole run. The Actor stops cleanly the moment this budget is reached and reports what it did not process — it never silently drops records.",
                        "default": 10
                    },
                    "onlyBelowScore": {
                        "title": "Only output sites scoring below",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Optional lead filter. Only sites scoring BELOW this number are written to the dataset — those are your actual leads. Leave empty to output every audited site. Note: filtered-out sites were still fully audited, so they are still charged; unreachable sites always pass the filter (a dead website is the strongest pitch there is)."
                    },
                    "extractEmails": {
                        "title": "Extract contact details",
                        "type": "boolean",
                        "description": "Collect emails, phone numbers and social links during the SAME browser visit that runs the audit (plus up to 2 contact/about pages). One visit, two jobs — this adds no extra charge.",
                        "default": true
                    },
                    "aiPitchSummary": {
                        "title": "Add an AI outreach pitch",
                        "type": "boolean",
                        "description": "Write a 2-sentence, ready-to-send pitch angle for each lead, referencing that site's specific problems. Charged $0.012 per pitch generated. Off by default.",
                        "default": false
                    },
                    "pitchTone": {
                        "title": "Pitch tone",
                        "enum": [
                            "consultative",
                            "direct",
                            "friendly"
                        ],
                        "type": "string",
                        "description": "Only used when the AI pitch is enabled.",
                        "default": "consultative"
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many sites are audited in parallel. Higher is faster but heavier — above 5, raise the run's memory to 4096 MB.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "OFF by default, on purpose. Ordinary business websites are visited once each and do not need a proxy, and routing through one measurably distorts the very numbers this Actor sells — load time and page weight. A residential proxy also bills per GB, and because the audit deliberately downloads images to weigh the page, that gets expensive fast. Turn a proxy on only if you see sites coming back as \"blocked\".",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
