# AI Icebreaker Generator - Personalized Cold Email First Lines (`jurassic_jove/icebreaker-generator`) Actor

Write personalized cold email opening lines from each prospect's real website. Visits the site, cites something specific, and returns first lines ready to import into Instantly, Smartlead, or lemlist. English and Spanish.

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

## Pricing

$8.00 / 1,000 lead processeds

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

## personalized first lines for cold email, written from each prospect's actual website

this AI icebreaker generator visits each lead's real website (homepage, about, services, latest blog posts), pulls something specific and citable, and writes cold email opening lines that prove you actually looked. not a bio rewriter, not a template spinner: a first line writer that reads the actual site.

generic first lines kill reply rates. "i hope this email finds you well" gets deleted on sight, and most "personalization" tools just reword the prospect's LinkedIn headline. specific beats generic, every time.

### 📊 what the output looks like

| lead | icebreaker | confidence |
|---|---|---|
| roofing company, Tampa | saw you guys just wrapped that 40-unit re-roof in Brandon, that's a serious project for a 6-man crew. | high |
| landscaping company, FL | your blog post on florida-friendly plants actually answered something i'd been wondering about st augustine grass. | high |
| dev tool startup | just read the gradcracker debugging story on your blog, three days of ai hallucinating solutions sounds painfully familiar. | high |
| site unreachable | figured i'd reach out to Dead Site Inc directly instead of going through a contact form | low |

every row keeps all your input columns and adds `icebreaker_1` to `icebreaker_3`, `fact_used` (the signal it cites), `confidence` (high / medium / low), `signal_source` (homepage / about / services / blog / fallback) and `detected_language` when you use auto language.

### ⚡ quick start

paste leads as JSON, or chain another actor's run with `datasetId`. each lead needs a website field (`websiteUrl`, `website`, `url` or `domain` all work). `companyName` and `contactName` are recommended but optional.

```json
{
    "leads": [
        { "websiteUrl": "https://tampabayroofers.com", "companyName": "Tampa Bay Roofers", "contactName": "Mike" }
    ],
    "senderContext": "i run a web design agency for home service contractors",
    "tone": "casual",
    "language": "en",
    "variantsPerLead": 2
}
````

`senderContext` is used to angle the line toward relevance. it is never pitched: the icebreaker only proves you looked.

### 📥 export to instantly, smartlead or lemlist

download the dataset as CSV and import directly. no column edits needed.

**instantly**

1. contacts, import, CSV
2. map `icebreaker_1` to a custom variable named `icebreaker`
3. use `{{icebreaker}}` as the first line of your email body

**smartlead**

1. lead list, import CSV
2. map `icebreaker_1` to a custom field (e.g. `first_line`)
3. reference it as `{{first_line}}` in your sequence

**lemlist**

1. campaign, leads, import CSV
2. map `icebreaker_1` to a custom variable
3. insert it with the variable picker in your template

tip: filter the CSV to `confidence != low` for your A-list sends, and keep the `low` rows for a separate generic-angle campaign.

### 🔗 chain it with your lead source

built to sit at the end of a lead-gen pipeline. run any of these, then pass the run's default dataset id as `datasetId`:

- [google maps lead generator](https://apify.com/jurassic_jove/google-maps-lead-generator) or the [pro version](https://apify.com/jurassic_jove/google-maps-lead-generator-pro)
- [website email extractor](https://apify.com/jurassic_jove/website-email-extractor)
- [tripadvisor lead generator](https://apify.com/jurassic_jove/tripadvisor-lead-generator)
- [email verifier + enricher](https://apify.com/jurassic_jove/email-verifier-enricher-pro)

emails, phones and every other column your scraper found ride along into the final CSV.

### 🚫 why these lines don't sound AI-generated

most AI first line writers produce openers that scream automation: "i was impressed by your commitment to delivering seamless solutions". this actor enforces a strict style contract:

- one specific fact per line. a recent project beats a service list, a blog post title beats "i saw your website"
- banned words: impressive, amazing, streamline, leverage, seamless, robust, elevate, unlock, empower, game-changer
- banned patterns: "i hope this email finds you well", "i came across your website", "it's not just X, it's Y", exclamation points, em dashes
- lines that slip through get caught by a validation pass and regenerated

### 🌎 cold email opening lines in spanish

set `language` to `es` for spanish first lines, or `auto` to detect each prospect's website language and match it. a lead list mixing miami contractors and mexico city agencies comes back with each icebreaker in the right language, marked in the `detected_language` column. spanish-language cold email is badly underserved by first line tools, and this is built for it: the fallback templates, the style rules and the signal extraction all work natively in spanish.

### 🛡️ what happens with bad leads

runs never fail because of a bad lead:

- dead site, timeout or blocked request: the lead gets a fallback line from its company name, marked `confidence: low`
- linktree or beacons page instead of a real site: the actor follows the main link and crawls the real website behind it
- empty single-page app with no readable text: treated as unreachable, fallback line
- the run summary counts every fallback by reason so you can judge list quality at a glance

### ❓ faq

**how is this different from pasting leads into chatgpt?**
scale and grounding. this visits every website, extracts real signals (projects, blog posts, certifications, years in business, service area) and cites them. no hallucinated compliments, no copy-paste loop, and the output lands as a CSV ready for your sequencer.

**what does a good cold email first line look like?**
specific, casual, and about them. "saw you guys just wrapped that 40-unit re-roof in Brandon" reads like a person typed it after visiting the site. that is the target, and the style rules exist to protect it.

**how many leads can i process per run?**
default cap is 500 per run, configurable with `maxLeads`. a 500-lead run typically finishes in a few minutes.

**does it work with lead lists from other scrapers?**
yes. field names are normalized automatically (`websiteUrl`, `website`, `url`, `domain`, and `companyName`, `company`, `name`), so output from most scrapers chains directly via `datasetId` without remapping.

**what if a lead has no website at all?**
it still gets a usable fallback line built from the company name, marked `confidence: low` and `signal_source: fallback` so you can filter it.

### 💸 pricing

pay per lead processed. a 1,000-lead list costs $8, which is 25-60x cheaper than human first line writers ($0.10-0.50 per line) and a fraction of what list agencies charge ($200-500 per 1k leads). the apify free tier covers a ~50 lead test run so you can check the quality on your own list before paying.

# Actor input Schema

## `leads` (type: `array`):

List of leads. Minimum per lead: websiteUrl. Recommended: companyName, contactName. Accepts direct paste or output from another Actor via datasetId.

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

Chain directly from a scraper run. Must contain a websiteUrl (or website/url/domain) field.

## `senderContext` (type: `string`):

1-2 sentences. Example: 'I run a web design agency for home service contractors.' Used to angle the icebreaker toward relevance, never to pitch.

## `tone` (type: `string`):

Writing tone for the icebreakers.

## `language` (type: `string`):

'auto' detects the language of the prospect's website and matches it.

## `variantsPerLead` (type: `integer`):

How many icebreaker variants to generate per lead (1-3).

## `maxLeads` (type: `integer`):

Hard cap on how many leads are processed in one run.

## Actor input object example

```json
{
  "leads": [
    {
      "websiteUrl": "https://example.com",
      "companyName": "Example Co",
      "contactName": "Jane"
    }
  ],
  "tone": "casual",
  "language": "en",
  "variantsPerLead": 2,
  "maxLeads": 500
}
```

# 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 = {
    "leads": [
        {
            "websiteUrl": "https://example.com",
            "companyName": "Example Co",
            "contactName": "Jane"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/icebreaker-generator").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 = { "leads": [{
            "websiteUrl": "https://example.com",
            "companyName": "Example Co",
            "contactName": "Jane",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/icebreaker-generator").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 '{
  "leads": [
    {
      "websiteUrl": "https://example.com",
      "companyName": "Example Co",
      "contactName": "Jane"
    }
  ]
}' |
apify call jurassic_jove/icebreaker-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Icebreaker Generator - Personalized Cold Email First Lines",
        "description": "Write personalized cold email opening lines from each prospect's real website. Visits the site, cites something specific, and returns first lines ready to import into Instantly, Smartlead, or lemlist. English and Spanish.",
        "version": "0.1",
        "x-build-id": "ApaZ5YtDmj5fqb2Ce"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~icebreaker-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-icebreaker-generator",
                "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~icebreaker-generator/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-icebreaker-generator",
                "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~icebreaker-generator/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-icebreaker-generator",
                "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": {
                    "leads": {
                        "title": "Leads",
                        "type": "array",
                        "description": "List of leads. Minimum per lead: websiteUrl. Recommended: companyName, contactName. Accepts direct paste or output from another Actor via datasetId."
                    },
                    "datasetId": {
                        "title": "Or: Dataset ID from another Actor run",
                        "type": "string",
                        "description": "Chain directly from a scraper run. Must contain a websiteUrl (or website/url/domain) field."
                    },
                    "senderContext": {
                        "title": "What you sell / who you are",
                        "type": "string",
                        "description": "1-2 sentences. Example: 'I run a web design agency for home service contractors.' Used to angle the icebreaker toward relevance, never to pitch."
                    },
                    "tone": {
                        "title": "Tone",
                        "enum": [
                            "casual",
                            "professional",
                            "direct"
                        ],
                        "type": "string",
                        "description": "Writing tone for the icebreakers.",
                        "default": "casual"
                    },
                    "language": {
                        "title": "Output language",
                        "enum": [
                            "en",
                            "es",
                            "auto"
                        ],
                        "type": "string",
                        "description": "'auto' detects the language of the prospect's website and matches it.",
                        "default": "en"
                    },
                    "variantsPerLead": {
                        "title": "Icebreakers per lead",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many icebreaker variants to generate per lead (1-3).",
                        "default": 2
                    },
                    "maxLeads": {
                        "title": "Max leads to process",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on how many leads are processed in one run.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```