# Lead Intelligence Engine (`valle/lead-intelligence-engine`) Actor

An intelligent Google Maps & website scanner for agencies and B2B teams. Automatically finds companies, extracts emails, phones, and socials, audits sites for SEO, legal, and UX issues, scores leads (A+–D), and generates personalized CTAs targeting real pain points. Perfect for sales prospecting.

- **URL**: https://apify.com/valle/lead-intelligence-engine.md
- **Developed by:** [Valentin Oeder](https://apify.com/valle) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 14 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 lead results

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.md):

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

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

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

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

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

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

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

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

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


# README

## Lead Intelligence Engine — Google Maps & Website Audit  
**Automatischer Lead-Finder für Agenturen und B2B-Vertrieb.**

---

### 🇩🇪 DEUTSCH

#### Übersicht
Der **Lead Intelligence Engine Scraper** durchsucht Google Maps nach Unternehmen, extrahiert Websites, E-Mails, Telefonnummern, WhatsApp-Nummern und Social-Links.  
Er prüft automatisch technische und rechtliche Aspekte (SSL, Impressum, Datenschutz, Mobile, SEO) und bewertet jeden Lead mit einem 100-Punkte-Score (A+ bis D).  
Das System generiert für jeden Kontakt direkt ein passendes, personalisiertes **Verkaufsargument (CTA)** auf Basis der gefundenen Schwächen.

#### Funktionen
- 🔍 Google Maps Suche nach Branche + Stadt  
- 🌐 Website-Analyse (E-Mail, Telefon, Socials, WhatsApp)  
- ⚖️ Rechts- und Technik-Check (Impressum, SSL, Mobile)  
- 📊 Lead-Scoring mit Opportunity-Ranking  
- 🧠 Automatische CTA-Texte (Pain-Points + Lösungen)  
- 📤 Export als CSV oder JSON  

#### Anwendungsfälle
- Agenturen, Web-Studios, SEO-Dienstleister, SaaS  
- Outbound-Sales & Prospecting  
- Lead-Verkauf (z. B. Google-Maps-Datenfeeds)  
- Marktanalyse & Wettbewerbs-Benchmark  

#### Input-Beispiel
```json
{
  "queries": ["Webdesign Agentur München"],
  "maxResultsPerQuery": 100,
  "includeWebsiteScan": true,
  "includeWhatsApp": true,
  "generateCta": true,
  "ctaLanguage": "de",
  "proxyConfig": { "useApifyProxy": true, "apifyProxyGroups": ["DE"] }
}
````

#### Output

- Name, Kategorie, Stadt, Website, E-Mail, Telefonnummer, WhatsApp
- SSL-Status, CMS, Mobile-Check, SEO-Meta, Ladezeit
- Opportunity-Score, CTA-Text, Argument-Trigger

#### Bewertungssystem

| Faktor | Gewicht |
| --- | --- |
| Kontakt (E-Mail, Telefon) | 30 |
| Recht & Vertrauen | 25 |
| Technik (SSL, Mobile) | 25 |
| SEO & Struktur | 20 |
| Reputation | 20 |

#### CTA-Beispiel

„Ich habe mir {{domain}} angesehen — {{issue\_1}} und {{issue\_2}}. Wir beheben das inkl. {{quick\_wins}}. Umsetzung < 5 Tage. Kurze Demo?“

***

### 🇬🇧 ENGLISH

#### Overview

The **Lead Intelligence Engine** scans Google Maps for businesses, extracting websites, emails, phone numbers, WhatsApp links, and social media profiles.\
It audits each website for SSL, legal compliance, mobile readiness, and SEO signals.\
Each result is scored (A+–D) and paired with a tailored sales message (CTA) that highlights the key weaknesses and actionable fixes.

#### Features

- 🔍 Google Maps business scraping (no API)
- 🌐 Website crawler for contact data, socials, WhatsApp
- ⚙️ Legal + technical audits (SSL, mobile, privacy, etc.)
- 📊 Smart lead scoring (0–100, A+–D)
- 🧠 AI-generated CTAs from detected pain points
- 📤 Export as CSV or JSON

#### Use Cases

- Web agencies, SEO firms, SaaS outbound teams
- Sales automation and cold outreach
- Data enrichment and lead resale
- Market research and benchmarking

#### Input Example

```json
{
  "queries": ["SEO Agency Berlin"],
  "maxResultsPerQuery": 100,
  "includeWebsiteScan": true,
  "includeWhatsApp": true,
  "generateCta": true,
  "ctaLanguage": "en",
  "proxyConfig": { "useApifyProxy": true, "apifyProxyGroups": ["DE"] }
}
```

#### Output

- Name, Category, Location, Website, Email, Phone, WhatsApp
- SSL status, CMS, Mobile readiness, Meta tags, Load time
- Opportunity score, CTA text, Argument trigger

#### Scoring Weights

| Factor | Weight |
| --- | --- |
| Contact signals | 30 |
| Legal & Trust | 25 |
| Technical health | 25 |
| SEO & Structure | 20 |
| Reputation | 20 |

#### Example CTA

“I reviewed {{domain}} — {{issue\_1}} and {{issue\_2}} are holding it back. We fix this and add {{quick\_wins}}. Ready to see a preview?”

***

#### Developer

**Valerius Data Systems — Oper8Labs**\
Website: [www.oper8labs.com](https://www.oper8labs.com)\
Contact: <valentin@oper8labs.com>\
Instagram: [@vallenextdoor](https://www.instagram.com/vallenextdoor)

#### Tags

lead-scraper, google-maps, automation, b2b, whatsapp, seo, marketing, data, intelligence

## Lead Intelligence Engine 🚀

**Intelligenter Lead-Scanner für B2B-Sales Teams**

Findet Firmen über Google Places API, analysiert ihre Websites, extrahiert Kontaktdaten, bewertet die Lead-Qualität und generiert automatisch Verkaufsargumente. Perfekt für Digital‑Agenturen, Webentwickler und Sales‑Teams.

### 🎯 Features

#### ✅ Zwei Betriebsmodi

- **SEARCH**: Google Maps Scraping (API Key optional - ohne Key: Web Scraping, mit Key: API)
- **WEBSITES**: Crawlt eine vordefinierte Domainliste

#### 📊 Advanced Lead-Scoring (100 Punkte System)

- **A+**: 85–100 Punkte (Premium Leads - sofort kontaktieren!)
- **A**: 75–84 Punkte
- **B**: 65–74 Punkte
- **C**: 50–64 Punkte
- **D**: <50 Punkte

**Scoring-Kategorien:**

- **Basis-Technik** (25 Punkte): SSL, Mobile-Optimierung
- **Reputation** (20 Punkte): Google-Bewertung, Anzahl Reviews
- **Kontakt-Qualität** (30 Punkte): E-Mails, Social Media Kanäle
- **Performance & SEO** (25 Punkte): Ladezeit, Analytics, Schema.org, Canonical, Hreflang
- **Recht & Compliance** (25 Punkte): Impressum, Datenschutz
- **CMS-Qualität** (5 Punkte): Moderne vs. veraltete Systeme

#### 🎁 Extrahiert

- **Kontaktdaten**: E-Mails (inkl. versteckter Felder), Telefonnummern (DE + Intl.)
- **Social Media**: Instagram, Facebook, LinkedIn, TikTok, YouTube, Twitter/X, WhatsApp, Telegram, Snapchat, Threads, Pinterest
- **SEO‑Metriken**: Meta‑Title, Meta‑Description, Schema.org, Canonical, Hreflang
- **Technical Profiling**: 20+ CMS‑Systeme, SSL, Mobile‑Optimierung, Load‑Time, Analytics
- **Rechtliche Compliance**: Impressum, Datenschutz (DSGVO)
- **Google‑Bewertungen**: Rating, Anzahl Reviews

#### 💡 Automatische Verkaufsargumente

Intelligente Priorisierung nach Verkaufswahrscheinlichkeit:

- **Kritisch** (Sofort handeln): SSL‑Fehler, fehlendes Impressum, DSGVO‑Verstöße, Website offline
- **Wichtig** (Hoher Impact): Mobile‑Optimierung, Ladezeit, Kontaktmöglichkeiten, Analytics, Social Media
- **Optimierung** (Nice-to-have): Schema.org Markup, CMS‑Modernisierung, Multi-Language (Hreflang)

### 🚀 Schnellstart

#### 1. Auf Apify hochladen

```bash
## Git-Repository pushen
git add .
git commit -m "Lead Intelligence Engine v1.0"
git push origin main
```

Auf https://console.apify.com einen neuen Actor erstellen und das Repository verbinden.

#### 2. Actor konfigurieren

##### Input Schema öffnen

Im Apify‑Console → Dein Actor → `INPUT_SCHEMA.json` prüfen:

```json
{
  "mode": "SEARCH",  // oder "WEBSITES"
  "searchStringsArray": ["Plastische Chirurgie"],
  "locationQueries": ["Stuttgart, Deutschland"],
  "maxCrawledPlacesPerSearch": 20,
  "useApifyProxy": true,
  "apifyProxyGroups": ["DE"],
  "googlePlacesApiKey": "DEIN_API_KEY",
  "maxConcurrency": 5
}
```

#### 3. Ersten Run starten

**SEARCH‑Modus (Google Maps):**

**Option A: Mit API Key (empfohlen - zuverlässiger)**

1. Mode: `SEARCH`
2. Suchbegriffe: z.B. `["Restaurants", "Cafes"]`
3. Orte: z.B. `["Berlin, Deutschland"]`
4. Max Plätze: `20` (empfohlen für den Start)
5. Google Places API Key: Dein API Key (optional, aber empfohlen)
6. Proxy aktivieren: `true`
7. **Run starten!**

**Option B: Ohne API Key (Web Scraping)**

1. Mode: `SEARCH`
2. Suchbegriffe: z.B. `["Restaurants", "Cafes"]`
3. Orte: z.B. `["Berlin, Deutschland"]`
4. Max Plätze: `20`
5. Google Places API Key: **Leer lassen** → Nutzt automatisch Web Scraping
6. Proxy aktivieren: `true` (wichtig für Scraping!)
7. **Run starten!**

**WEBSITES‑Modus (Domain‑Liste):**

1. Mode: `WEBSITES`
2. Websites:

```json
[
  "https://beispiel-firma.de",
  "https://andere-firma.com"
]
```

3. **Run starten!**

### 📥 Ergebnisse exportieren

Nach erfolgreichem Run → Dataset → **Download als CSV**

#### CSV‑Spalten

| Spalte | Beschreibung | Beispiel |
|--------|--------------|----------|
| `title` | Firmenname | "Beispiel GmbH" |
| `city` | Stadt | "Stuttgart" |
| `website` | Website URL | "https://beispiel.de" |
| `email` | E‑Mail(s) | "info@beispiel.de, verkauf@beispiel.de" |
| `phone` | Telefonnummer | "+49 711 123456" |
| `rating` | Google‑Bewertung | 4.5 |
| `reviews` | Anzahl Reviews | 127 |
| `ssl` | HTTPS aktiv? | true/false |
| `cms` | CMS‑System | "WordPress", "Webflow", "Next.js", etc. |
| `mobile` | Mobile‑optimiert? | true/false |
| `socials` | Social‑Media‑Links | JSON‑String |
| `website_status` | Status | "online", "offline", "error" |
| `load_ms` | Ladezeit | 1850 |
| `lead_score` | Score 0–100 | 75 |
| `grade` | Bewertung A–D | "B" |
| `argument_trigger` | Verkaufsargument | "🚨 Kein SSL‑Zertifikat..." |
| `meta_title` | SEO‑Title | "Beispiel GmbH – Ihre Agentur" |
| `meta_description` | SEO‑Description | "Wir bieten..." |
| `has_impressum` | Impressum vorhanden? | true/false |
| `has_privacy` | Datenschutz vorhanden? | true/false |
| `has_schemas` | Schema.org Markup? | true/false |
| `has_analytics` | Analytics installiert? | true/false |
| `hreflang` | Multi-Language SEO? | true/false |
| `canonical` | Canonical URL? | true/false |

### ⚙️ Erweiterte Konfiguration

#### Proxy‑Einstellungen

Standard: `apifyProxyGroups: ["DE"]`

Weitere Optionen:

- `["US"]` für USA
- `["AUTO"]` für automatische Auswahl
- `["US", "DE", "FR"]` für Multi‑Region

#### Parallelität

`maxConcurrency`: 1–20 gleichzeitige Website‑Scans

Empfehlung:

- **Kleine Runs** (<50): 5
- **Mittel** (50–200): 10
- **Groß** (>200): 15–20

### 🔧 Technischer Stack

- **Apify SDK v3**: Actor‑Framework
- **Google Places API**: Offizielle Google‑API für Firmendaten
- **Cheerio**: HTML‑Parsing
- **Axios**: HTTP‑Requests
- **Node.js**: Runtime

### 💰 Kosten

#### SEARCH‑Modus

**Ohne API Key (Web Scraping):**

- ✅ **Kostenlos** - Keine API-Kosten
- ⚠️ Weniger zuverlässig (kann durch Google Bot-Detection beeinträchtigt werden)
- Nur Apify Compute Units

**Mit API Key (Google Places API):**

- **Kosten**: ~$0.03 pro Suchbegriff‑Ort‑Kombination
- **Details**: $0.017 pro Place Details abruf
- **Kostenloses Guthaben**: $200/Monat von Google
- ✅ **Zuverlässigste Methode**
- Apify Compute Units: Zusätzlich je nach Volumen
- **Empfehlung**: Start mit 20 Places

#### WEBSITES‑Modus

- Keine Extern‑Kosten
- Nur Apify Compute Units

### 🐛 Troubleshooting

#### "Keine Ergebnisse gefunden"

- Erhöhe Wartezeiten im Code
- Prüfe `searchStringsArray` und `locationQueries`
- Aktiviere Proxy

#### "Website offline/error"

- Normal bei defekten Domains
- Prüfe URLs im WEBSITES‑Modus

#### "Timeout Error"

- Reduziere `maxConcurrency`
- Erhöhe Timeouts im Code

### 📚 Beispiel‑Use Cases

#### 1. CRM‑Enrichment

Finde fehlende Kontaktdaten, Social Media Profiles und SEO-Scoring für bestehende Leads.

#### 2. Wettbewerbsanalyse

Scanne den Markt, analysiere CMS‑Auswahl, SEO‑Qualität und identifiziere Verbesserungsfelder.

#### 3. Outbound‑Sales

Generiere qualifizierte Lead‑Listen mit automatischen, priorisierten Verkaufsargumenten (Kritisch → Wichtig → Nice-to-have).

#### 4. Agency‑Prospecting

Suche z. B. "Webdesign Agentur München" und biete Services passend zum technischen Profil der Leads.

#### 5. Lead‑Qualifizierung

Automatisches Scoring (A-D) für Fokussierung auf hochwertige Leads.

**Warum besser als andere?**
✅ **Datenqualität**: Robuste Regex für E-Mails + Telefon (DE + Intl.), erkennt auch versteckte Felder\
✅ **Social Media**: 11 Plattformen (Instagram, FB, LinkedIn, TikTok, YouTube, X, WhatsApp, Telegram, Snapchat, Threads, Pinterest)\
✅ **CMS-Erkennung**: 20+ Systeme (WordPress, Shopify, Wix, Next.js, Nuxt, CraftCMS, Strapi, TYPO3, etc.)\
✅ **SEO**: Schema.org, Canonical URLs, Hreflang, Meta-Tags, Analytics-Detection\
✅ **Scoring**: 100-Punkte System mit 6 Kategorien + A+ Rating für Premium Leads\
✅ **Recht**: Automatische Impressum & Datenschutz-Checks\
✅ **Performance**: Load-Time Tracking mit granularer Bewertung\
✅ **Lead-Argumente**: Intelligente Priorisierung (Kritisch → Wichtig → Optimierung)\
✅ **Deutsch**: Bessere Heuristik für deutsche Firmennamen (GmbH, AG, etc.)

### 🤝 Contributing

Feedback und Pull Requests gerne über GitHub.

### 📄 Lizenz

MIT

### 🆘 Support

Issues: GitHub Repo\
Documentation: https://docs.apify.com/actors/development

***

**Happy Lead Hunting! 🎯**

# Actor input Schema

## `mode` (type: `string`):

SEARCH = Google Maps (mit API Key: zuverlässig, ohne: Web Scraping); WEBSITES = feste Domainliste crawlen.

## `searchStringsArray` (type: `array`):

Nur für SEARCH.

## `locationQueries` (type: `array`):

Nur für SEARCH.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Maximale Anzahl an Google Maps Ergebnissen pro Suchbegriff-Ort-Kombination.

## `maxLocalSearchPages` (type: `integer`):

Anzahl der Google-Local-Search-Seiten (tbm=lcl) pro Suche. Jede Seite liefert ca. 20 Einträge.

## `websites` (type: `array`):

Nur für WEBSITES. Volle URLs inkl. https://

## `useApifyProxy` (type: `boolean`):

Aktiviert das Apify Proxy-Netzwerk für bessere Anonymität und Rate-Limiting.

## `apifyProxyGroups` (type: `array`):

Proxy-Gruppen für geografische Zielung (z.B. DE, US, AUTO).

## `googlePlacesApiKey` (type: `string`):

Optional für SEARCH-Modus. Ohne Key wird Web Scraping genutzt. Mit Key: Zuverlässiger (~$0.03/Suche, $200/Monat kostenlos).

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

Anzahl gleichzeitiger Website-Crawls (1-20 empfohlen, Standard: 3 für stabilere Scans ohne Timeouts).

## `outputLanguage` (type: `string`):

Steuert, ob CTA-Texte auf Deutsch oder Englisch generiert werden.

## Actor input object example

```json
{
  "mode": "SEARCH",
  "searchStringsArray": [
    "Plastische Chirurgie"
  ],
  "locationQueries": [
    "Stuttgart, Deutschland"
  ],
  "maxCrawledPlacesPerSearch": 20,
  "maxLocalSearchPages": 3,
  "useApifyProxy": true,
  "apifyProxyGroups": [
    "DE"
  ],
  "maxConcurrency": 3,
  "outputLanguage": "de"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("valle/lead-intelligence-engine").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("valle/lead-intelligence-engine").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 '{}' |
apify call valle/lead-intelligence-engine --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lead Intelligence Engine",
        "description": "An intelligent Google Maps & website scanner for agencies and B2B teams. Automatically finds companies, extracts emails, phones, and socials, audits sites for SEO, legal, and UX issues, scores leads (A+–D), and generates personalized CTAs targeting real pain points. Perfect for sales prospecting.",
        "version": "0.0",
        "x-build-id": "HB0qPbgnJ11al3oyv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/valle~lead-intelligence-engine/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-valle-lead-intelligence-engine",
                "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/valle~lead-intelligence-engine/runs": {
            "post": {
                "operationId": "runs-sync-valle-lead-intelligence-engine",
                "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/valle~lead-intelligence-engine/run-sync": {
            "post": {
                "operationId": "run-sync-valle-lead-intelligence-engine",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Modus",
                        "enum": [
                            "SEARCH",
                            "WEBSITES"
                        ],
                        "type": "string",
                        "description": "SEARCH = Google Maps (mit API Key: zuverlässig, ohne: Web Scraping); WEBSITES = feste Domainliste crawlen.",
                        "default": "SEARCH"
                    },
                    "searchStringsArray": {
                        "title": "Suchbegriffe",
                        "type": "array",
                        "description": "Nur für SEARCH.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Plastische Chirurgie"
                        ]
                    },
                    "locationQueries": {
                        "title": "Orte",
                        "type": "array",
                        "description": "Nur für SEARCH.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Stuttgart, Deutschland"
                        ]
                    },
                    "maxCrawledPlacesPerSearch": {
                        "title": "Max Plätze je Suche",
                        "type": "integer",
                        "description": "Maximale Anzahl an Google Maps Ergebnissen pro Suchbegriff-Ort-Kombination.",
                        "default": 20
                    },
                    "maxLocalSearchPages": {
                        "title": "Max Local-Search Seiten",
                        "type": "integer",
                        "description": "Anzahl der Google-Local-Search-Seiten (tbm=lcl) pro Suche. Jede Seite liefert ca. 20 Einträge.",
                        "default": 3
                    },
                    "websites": {
                        "title": "Websites",
                        "type": "array",
                        "description": "Nur für WEBSITES. Volle URLs inkl. https://",
                        "items": {
                            "type": "string"
                        }
                    },
                    "useApifyProxy": {
                        "title": "Apify Proxy nutzen",
                        "type": "boolean",
                        "description": "Aktiviert das Apify Proxy-Netzwerk für bessere Anonymität und Rate-Limiting.",
                        "default": true
                    },
                    "apifyProxyGroups": {
                        "title": "Proxy-Gruppen",
                        "type": "array",
                        "description": "Proxy-Gruppen für geografische Zielung (z.B. DE, US, AUTO).",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "DE"
                        ]
                    },
                    "googlePlacesApiKey": {
                        "title": "Google Places API Key (Optional)",
                        "type": "string",
                        "description": "Optional für SEARCH-Modus. Ohne Key wird Web Scraping genutzt. Mit Key: Zuverlässiger (~$0.03/Suche, $200/Monat kostenlos)."
                    },
                    "maxConcurrency": {
                        "title": "Maximale Parallelität",
                        "type": "integer",
                        "description": "Anzahl gleichzeitiger Website-Crawls (1-20 empfohlen, Standard: 3 für stabilere Scans ohne Timeouts).",
                        "default": 3
                    },
                    "outputLanguage": {
                        "title": "Output-Sprache",
                        "enum": [
                            "de",
                            "en"
                        ],
                        "type": "string",
                        "description": "Steuert, ob CTA-Texte auf Deutsch oder Englisch generiert werden.",
                        "default": "de"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
