# Qualified B2B Leads on Demand — Pay Per Verified Lead (`noniner/qualified-leads`) Actor

Bring your target company domains and get verified, ICP-matched, intent-scored decision-maker leads scraped from the companies' own sites. You pay only for leads that qualify; unverified or off-ICP rows are free.

- **URL**: https://apify.com/noniner/qualified-leads.md
- **Developed by:** [Fredrik Hansson](https://apify.com/noniner) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1,500.00 / 1,000 qualified lead delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## Qualified B2B Leads on Demand — Pay Per Verified Lead

Bring your target company domains. Get back **verified, ICP-matched, intent-scored
decision-maker leads** — and **pay only for the leads that qualify**. Unverified,
off-ICP or contactless rows are returned free.

No people-database guesswork: every contact is a **real named person scraped from the
company's own site** (homepage + about/team/contact pages), mapped to a **real on-page
email**. The Actor never invents a person or an email.

### How it works

For each domain:

1. Fetch the homepage plus its about / team / leadership / contact pages.
2. Extract real on-page emails and the LinkedIn company link (deterministic, no AI).
3. One AI pass: firmographics, ICP **fit score**, explicit **intent signals**, and the
   **named decision-makers** matched to your wanted roles — emails only from the real
   on-page candidates.
4. **Verify** each email (syntax + MX records + role/catch-all classification).
5. **Qualify** against your bar. Charge one `qualified-lead` event per lead that passes.

### Qualification bar (what you pay for)

A lead is **qualified** (and the only thing charged) when:

- `fitScore >= minFitScore`, and
- it matches a `rolesWanted` title (if you set any), and
- it has a deliverable email (`requireVerifiedEmail` → a verified personal address), and
- it shows a buying-intent signal (only if `requireIntentSignal` is on).

Everything else is delivered with `qualified: false` and a `disqualifiedReason`, free.

### Input

| Field | Type | Notes |
|---|---|---|
| `domains` | string\[] | Target companies (domain, URL or email). Required. |
| `icp` | string | Who you sell to. Drives the fit score. Required. |
| `rolesWanted` | string\[] | Titles to target. Empty = any senior contact. |
| `minFitScore` | integer | Default 70. |
| `requireVerifiedEmail` | boolean | Default true. |
| `requireIntentSignal` | boolean | Default false. |
| `maxQualifiedLeads` | integer | Budget cap. Default 25. |

### Output (one record per person)

```json
{
  "company": { "name": "Acme", "domain": "acme.com", "industry": "SaaS", "sizeSignal": "50-200", "location": "US", "techStack": ["HubSpot"] },
  "contact": { "fullName": "Jane Doe", "title": "VP Sales", "email": "jane@acme.com", "emailStatus": "verified", "linkedinUrl": "https://linkedin.com/company/acme" },
  "fitScore": 86,
  "fitReasons": ["Sells to SMBs", "Hiring SDRs"],
  "intentSignals": ["Hiring SDRs"],
  "roleMatch": true,
  "opener": "Saw you're scaling the SDR team...",
  "qualified": true
}
```

### About email verification (be clear)

SMTP port 25 is blocked on this infrastructure, so there is **no live SMTP handshake**.
`emailStatus` is:

- `verified` — a personal address found on the site, domain MX-valid (highest confidence).
- `inferred` — the person is named on the site but no email was published, so we built the
  standard pattern (first.last@domain) and confirmed the domain accepts mail. A high-probability
  guess, not confirmed — like Hunter/Apollo pattern matches.
- `risky` — a personal address on a free provider (gmail etc.).
- `role` — a generic inbox (info@); never attributed to a named person.
- `invalid` / `none` — bad syntax, no MX, or nothing found.

`requireVerifiedEmail: true` qualifies only `verified` leads. Set it `false` to also accept
`inferred` and `risky`. No SMTP handshake is performed (port 25 blocked); for hard mailbox
verification, run the output through a dedicated verifier.

### Pricing

**$1.50 per qualified lead.** Nothing else is charged. A single closed deal pays for
hundreds of leads.

### Compliance

Returns business, role-based contact data from public company pages. You are the data
controller for how you use it (GDPR/CAN-SPAM apply to your outreach).

### Part of the No Niner no-code data toolkit

Browse 50+ chainable AI data tools at **[noniner.io](https://noniner.io)**.

# Actor input Schema

## `domains` (type: `array`):

Companies to find leads at (one domain, website URL or email per line).

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

Describe your ideal customer in plain English. Drives the fit score for every company.

## `rolesWanted` (type: `array`):

Titles to target, e.g. VP Sales, Head of Growth, Founder. Empty = any senior contact.

## `minFitScore` (type: `integer`):

A lead must score at least this (0-100) against your ICP to qualify (and be charged).

## `requireVerifiedEmail` (type: `boolean`):

Only qualify leads with a deliverable personal email (MX-valid, not a generic role inbox).

## `requireIntentSignal` (type: `boolean`):

Only qualify leads at companies showing an explicit intent signal (hiring, funding, launch).

## `maxQualifiedLeads` (type: `integer`):

Stop once this many qualified leads are delivered. You are charged per qualified lead.

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

Companies processed in parallel.

## `model` (type: `string`):

Override the extraction model (default gpt-4o-mini).

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "icp": "B2B SaaS and data teams that need web scraping, automation or lead generation.",
  "rolesWanted": [
    "Founder",
    "CEO",
    "Head of Product"
  ],
  "minFitScore": 70,
  "requireVerifiedEmail": true,
  "requireIntentSignal": false,
  "maxQualifiedLeads": 25,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `leads` (type: `string`):

All lead records (qualified and free) in the default dataset.

# 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 = {
    "domains": [
        "apify.com"
    ],
    "icp": "B2B SaaS and data teams that need web scraping, automation or lead generation.",
    "rolesWanted": [
        "Founder",
        "CEO",
        "Head of Product"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("noniner/qualified-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 = {
    "domains": ["apify.com"],
    "icp": "B2B SaaS and data teams that need web scraping, automation or lead generation.",
    "rolesWanted": [
        "Founder",
        "CEO",
        "Head of Product",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("noniner/qualified-leads").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com"
  ],
  "icp": "B2B SaaS and data teams that need web scraping, automation or lead generation.",
  "rolesWanted": [
    "Founder",
    "CEO",
    "Head of Product"
  ]
}' |
apify call noniner/qualified-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,noniner/qualified-leads"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/klqMbM8R8BiJgB0cX/builds/PJNRidZgWRL3r55Hy/openapi.json