# Pipedrive Lead Pusher — Sync Leads to CRM (`ryanclinton/pipedrive-lead-pusher`) Actor

Syncs scraped leads into Pipedrive CRM as organizations, persons, and deals. Duplicate detection, ICP score filtering, dry-run preview, and dataset chaining from any Apify actor. $0.05/lead.

- **URL**: https://apify.com/ryanclinton/pipedrive-lead-pusher.md
- **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Pipedrive Lead Pusher

Pipedrive Lead Pusher automatically syncs scraped leads into your Pipedrive CRM — creating organizations, persons, and optional deals in one run. Built for sales teams, growth agencies, and RevOps operators who generate leads at scale and need them in Pipedrive without manual data entry. Connect it directly to the output of any Apify lead generation actor and your CRM stays current.

The actor accepts leads either inline (paste JSON directly) or from any Apify dataset ID, making it the natural final step in a web scraping pipeline. It maps company data to organizations, contacts to persons, and can optionally open a deal for each lead — all with automatic duplicate detection and a safe dry-run preview before any data is committed to your CRM.

### What data can you push to Pipedrive?

| Data Point | Source field | Pipedrive entity |
|---|---|---|
| 📦 **Company name** | `companyName` or derived from `domain` | Organization → name |
| 🌐 **Website / domain** | `domain` or `website` | Organization → web |
| 📍 **Full address** | `address`, `city`, `state`, `zip`, `country` | Organization → address |
| 👤 **Contact name** | `contacts[].name` | Person → name |
| 📧 **Contact email** | `contacts[].email`, `emails[]`, `email` | Person → email |
| 📞 **Contact phone** | `contacts[].phone`, `phones[]`, `phone` | Person → phone |
| 💼 **Job title** | `contacts[].title` | Person → job_title |
| 🔗 **Organization link** | Auto-linked after org creation | Person → org_id |
| 📋 **Deal title** | Template: `New Lead: {{companyName}}` | Deal → title |
| 📊 **Deal stage** | `dealStageId` | Deal → stage_id |
| 🏆 **ICP score filter** | `icpScore` or `score` | Pre-push filter only |
| 🔁 **Dedup status** | Pipedrive org name search | Organization → skipped if exists |

### Why use Pipedrive Lead Pusher?

Manually importing leads into Pipedrive wastes hours. CSV uploads break field mappings, create duplicates, and require reformatting every time your data source changes. A data entry contractor costs $20-40/hour and still makes mistakes on name parsing, address formatting, and contact-to-company linking.

This actor automates the entire CRM sync process — field mapping, deduplication search, sequential API creates, rate limit handling, and per-lead error reporting — so your pipeline runs end with a populated Pipedrive account rather than a spreadsheet waiting for human action.

- **Scheduling** — run daily, weekly, or on a custom interval to keep Pipedrive in sync with fresh scraping output
- **API access** — trigger runs from Python, JavaScript, or any HTTP client as part of a fully automated workflow
- **Dataset chaining** — pass any Apify dataset ID directly; no intermediate file exports required
- **Monitoring** — get Slack or email alerts when runs fail or encounter errors via Apify's built-in notifications
- **Integrations** — combine with Zapier, Make, or webhooks to trigger downstream actions when new records land in Pipedrive

### Features

- **Automatic organization creation** — maps `companyName`, full address fields, and website domain into a Pipedrive organization record
- **Multi-contact person creation** — creates one person record per unique email found across `contacts[]`, `emails[]`, and `email` fields; all persons are linked to their parent organization via `org_id`
- **Optional deal creation with templated titles** — deal titles use `{{companyName}}`, `{{domain}}`, `{{icpScore}}`, `{{icpGrade}}`, `{{city}}`, `{{country}}`, and `{{industry}}` template variables rendered per lead
- **Duplicate organization detection** — before creating an org, searches Pipedrive's `/organizations/search` endpoint by name; skips creation and reuses the existing `org_id` when a match is found
- **ICP score pre-filter** — filter out low-quality leads before they hit the Pipedrive API by setting `minIcpScore`; reads `icpScore` or `score` fields produced by compatible scoring actors
- **Dry-run preview mode** — default `dryRun: true` previews exactly what would be created in Pipedrive without making a single API call; verify field mapping before committing
- **Automatic token validation** — verifies the Pipedrive API token against `/users/me` before processing any leads, surfaces misconfiguration immediately
- **Rate-limit resilient client** — respects Pipedrive's 10 req/s limit with a 200ms inter-lead delay and 100ms inter-person delay; exponential backoff on 429 responses (2s, 4s, 8s) with up to 3 retries
- **Configurable deal stage** — assign new deals to a specific pipeline stage via `dealStageId`; defaults to your pipeline's first stage when omitted
- **Per-lead status tracking** — each output record carries a `status` of `success`, `partial`, `error`, or `dry_run` plus a full `errors[]` array for debugging
- **Spending limit enforcement** — stops processing when the Apify budget cap is reached, preserving all records pushed so far
- **Dataset or inline input** — accepts leads as a JSON array in the input field or pulls up to 1,000 records from any Apify dataset ID; works with any upstream actor
- **Run summary record** — the final record in every dataset is a typed `summary` object with totals for orgs created, persons created, deals created, dedup skips, score-filtered leads, and errors

### Use cases for Pipedrive lead import

#### Sales prospecting pipeline automation

SDRs and BDRs who scrape lead lists from Google Maps, LinkedIn, or company directories need those contacts in Pipedrive before the first outreach call. This actor closes the gap between "data collected" and "contact created" — pass a dataset ID from [Google Maps Email Extractor](https://apify.com/ryanclinton/google-maps-email-extractor) or [Website Contact Scraper](https://apify.com/ryanclinton/website-contact-scraper), set `createDeals: true`, and every prospect appears in Pipedrive as a linked org, person, and open deal within minutes.

#### Growth agency client delivery

Agencies running lead generation campaigns for clients often need to deliver qualified contacts directly into the client's Pipedrive account. Configure the actor with the client's API token and company domain, run it against the scored output from [B2B Lead Qualifier](https://apify.com/ryanclinton/b2b-lead-qualifier), and set `minIcpScore: 70` to deliver only the highest-quality prospects. The dry-run output serves as a preview deliverable before the client approves the final sync.

#### Automated CRM enrichment from scheduled scrapes

Teams running weekly competitive scrapes or market monitoring need CRM records to stay current without manual imports. Schedule this actor to run immediately after any pipeline actor completes, using a webhook trigger. Combine with `skipDuplicateOrgs: true` so companies already in Pipedrive are linked — not duplicated — when their contacts are updated.

#### RevOps pipeline population at scale

Revenue operations teams building initial CRM populations from large prospect lists — conference attendees, trade directory exports, Google Maps searches — need bulk import with deduplication. This actor processes up to 1,000 leads per run with per-record error logging, so the ops team can identify and re-run failed records without starting over.

#### Event and conference lead capture

Teams who collect leads at trade shows or conferences can push badge-scan exports or manual lists through this actor to populate Pipedrive immediately. Use the `contacts[]` array to pass multiple contacts per company and the deal title template to include event context: `"{{companyName}} — ExpoWest 2025"`.

#### Outbound campaign list building

Marketers building targeted outbound campaigns in tools like Lemlist or Salesloft often start in Pipedrive. Run [Waterfall Contact Enrichment](https://apify.com/ryanclinton/waterfall-contact-enrichment) to find verified emails, then push the results here. Every enriched contact lands in Pipedrive as a person linked to their organization, ready to be added to a sequence.

### How to push leads into Pipedrive CRM

1. **Get your Pipedrive API token** — in Pipedrive, go to Settings > Personal preferences > API and copy your personal API token. Also note your company subdomain (the part before `.pipedrive.com`).

2. **Prepare your leads** — paste lead objects directly into the `leads` field, or enter the dataset ID from a previous Apify actor run (find it in the Run's output tab). Each lead needs at minimum a `companyName` or `domain`.

3. **Preview with dry run** — leave `dryRun` checked (it defaults to `true`) and click Start. The actor maps all your data to Pipedrive format and returns the full preview in the Dataset tab — no records are created in Pipedrive yet.

4. **Go live** — uncheck `dryRun`, click Start again. The actor verifies your token, creates organizations, persons, and deals in Pipedrive sequentially, and outputs a per-lead status record. Download the JSON or CSV from the Dataset tab to see exactly what was created.

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `pipedriveApiToken` | string | No | — | Pipedrive personal API token. Settings > Personal preferences > API. Leave blank for dry-run preview. |
| `pipedriveCompanyDomain` | string | **Yes** | `yourcompany` | Your Pipedrive subdomain (e.g. `acme` for `acme.pipedrive.com`). |
| `leads` | array | No* | — | Inline lead objects. Each needs at least `companyName` or `domain`. Mutually exclusive with `datasetId`. |
| `datasetId` | string | No* | — | Apify dataset ID to pull leads from (up to 1,000 items). Use output from upstream pipeline actors. |
| `createOrganizations` | boolean | No | `true` | Create a Pipedrive organization record per lead. |
| `createPersons` | boolean | No | `true` | Create person records from `contacts[]` and `emails[]`, linked to their org. |
| `createDeals` | boolean | No | `false` | Create a deal per lead, linked to the org and first person. |
| `skipDuplicateOrgs` | boolean | No | `true` | Search Pipedrive for existing orgs by name before creating. Reuses the existing org ID. |
| `dealTitle` | string | No | `New Lead: {{companyName}}` | Deal title template. Supports `{{companyName}}`, `{{domain}}`, `{{icpScore}}`, `{{icpGrade}}`, `{{city}}`, `{{country}}`, `{{industry}}`. |
| `dealStageId` | integer | No | — | Pipedrive stage ID for new deals. Find IDs at Settings > Pipeline. |
| `minIcpScore` | integer | No | — | Minimum `icpScore` (or `score`) threshold. Leads below this value are skipped before any API calls. Range: 0–100. |
| `dryRun` | boolean | No | `true` | Preview mapped Pipedrive payloads without creating records. Auto-enabled if no API token is provided. |

*Either `leads` or `datasetId` must be provided.

#### Input examples

**Dry-run preview with inline leads (most common starting point):**
```json
{
    "pipedriveCompanyDomain": "acmesales",
    "dryRun": true,
    "leads": [
        {
            "companyName": "Pinnacle Industries",
            "domain": "pinnacleindustries.com",
            "city": "Denver",
            "state": "CO",
            "country": "United States",
            "industry": "Manufacturing",
            "icpScore": 87,
            "icpGrade": "A",
            "contacts": [
                {
                    "name": "Marcus Webb",
                    "title": "VP of Operations",
                    "email": "marcus.webb@pinnacleindustries.com",
                    "phone": "+1-720-555-0134"
                }
            ]
        }
    ]
}
````

**Live push from dataset with deal creation and score filter:**

```json
{
    "pipedriveApiToken": "YOUR_PIPEDRIVE_TOKEN",
    "pipedriveCompanyDomain": "acmesales",
    "datasetId": "abc123xyz456datasetId",
    "createOrganizations": true,
    "createPersons": true,
    "createDeals": true,
    "skipDuplicateOrgs": true,
    "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
    "dealStageId": 3,
    "minIcpScore": 65,
    "dryRun": false
}
```

**Minimal live push — organizations only, no deals:**

```json
{
    "pipedriveApiToken": "YOUR_PIPEDRIVE_TOKEN",
    "pipedriveCompanyDomain": "betacorp",
    "createOrganizations": true,
    "createPersons": false,
    "createDeals": false,
    "skipDuplicateOrgs": true,
    "dryRun": false,
    "leads": [
        { "companyName": "Redwood Logistics", "domain": "redwoodlogistics.com" },
        { "companyName": "Summit Analytics", "domain": "summitanalytics.io" }
    ]
}
```

#### Input tips

- **Always start with dry run** — the default `dryRun: true` shows you exactly how your lead fields map to Pipedrive before a single record is created. Check the output dataset to confirm names, addresses, and emails look right.
- **Use `datasetId` for pipeline automation** — copy the dataset ID from any upstream Apify actor run (visible in the Run page) and paste it here instead of duplicating lead data in the input.
- **Set `minIcpScore` when chaining with a scoring actor** — if your leads come from [B2B Lead Qualifier](https://apify.com/ryanclinton/b2b-lead-qualifier) or [B2B Lead Gen Suite](https://apify.com/ryanclinton/b2b-lead-gen-suite), they carry `icpScore` values. Set `minIcpScore: 60` to push only qualified leads and avoid polluting Pipedrive with low-grade prospects.
- **Find your `dealStageId` in Pipedrive** — go to Settings > Pipeline, then inspect the stage URL or use the Pipedrive API at `/stages` to get numeric IDs. Using the wrong ID causes deal creation to fall back to stage 1 silently.
- **Batch up to 1,000 leads per run** — the actor loads up to 1,000 items from a dataset in one run. For larger lists, split your dataset or run the actor multiple times with different dataset pages.

### Output example

```json
{
    "domain": "pinnacleindustries.com",
    "companyName": "Pinnacle Industries",
    "status": "success",
    "dryRun": false,
    "organization": {
        "id": 58312,
        "name": "Pinnacle Industries",
        "status": "created",
        "error": null
    },
    "persons": [
        {
            "id": 104891,
            "name": "Marcus Webb",
            "email": "marcus.webb@pinnacleindustries.com",
            "status": "created",
            "error": null
        }
    ],
    "deal": {
        "id": 29445,
        "title": "New Lead: Pinnacle Industries (Score: 87)",
        "status": "created",
        "error": null
    },
    "errors": [],
    "extractedAt": "2025-06-15T14:23:07.441Z"
}
```

**Summary record (final item in every dataset):**

```json
{
    "type": "summary",
    "totalLeads": 48,
    "leadsSkippedByScore": 11,
    "orgsCreated": 31,
    "orgsDedupSkipped": 6,
    "personsCreated": 44,
    "dealsCreated": 37,
    "errors": 0,
    "dryRun": false,
    "extractedAt": "2025-06-15T14:28:51.003Z"
}
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `domain` | string | Lead company domain or URL used to identify the record |
| `companyName` | string | Company name as pushed to Pipedrive (or derived from domain) |
| `status` | string | Overall result: `success`, `partial`, `error`, `dry_run`, or `skipped` |
| `dryRun` | boolean | `true` if this record was generated without calling the Pipedrive API |
| `organization.id` | number or null | Pipedrive organization ID (null in dry-run or on error) |
| `organization.name` | string | Organization name sent to Pipedrive |
| `organization.status` | string | `created`, `skipped_duplicate`, `dry_run`, or `error` |
| `organization.error` | string or null | Error message if org creation failed |
| `persons[].id` | number or null | Pipedrive person ID |
| `persons[].name` | string | Person display name |
| `persons[].email` | string | Email address used for this person record |
| `persons[].status` | string | `created`, `dry_run`, or `error` |
| `persons[].error` | string or null | Error message if person creation failed |
| `deal.id` | number or null | Pipedrive deal ID |
| `deal.title` | string | Rendered deal title after template substitution |
| `deal.status` | string | `created`, `dry_run`, or `error` |
| `deal.error` | string or null | Error message if deal creation failed |
| `errors` | string\[] | All error messages encountered while processing this lead |
| `extractedAt` | string | ISO 8601 timestamp when this lead was processed |
| `type` | string | Set to `summary` on the final aggregate record |
| `totalLeads` | number | (Summary) Total leads processed in this run |
| `leadsSkippedByScore` | number | (Summary) Leads filtered out by `minIcpScore` |
| `orgsCreated` | number | (Summary) New organizations created in Pipedrive |
| `orgsDedupSkipped` | number | (Summary) Organizations that already existed and were reused |
| `personsCreated` | number | (Summary) New persons created in Pipedrive |
| `dealsCreated` | number | (Summary) New deals created in Pipedrive |
| `errors` | number | (Summary) Count of leads that produced at least one error |

### How much does it cost to push leads into Pipedrive?

Pipedrive Lead Pusher uses **pay-per-event pricing** — you pay **$0.05 per lead processed**. Platform compute costs are included. Dry-run leads count toward billing the same as live pushes.

| Scenario | Leads | Cost per lead | Total cost |
|---|---|---|---|
| Quick test | 1 | $0.05 | $0.05 |
| Small batch | 20 | $0.05 | $1.00 |
| Medium batch | 100 | $0.05 | $5.00 |
| Large batch | 500 | $0.05 | $25.00 |
| Enterprise | 1,000 | $0.05 | $50.00 |

You can set a **maximum spending limit** per run to control costs. The actor stops when your budget is reached, and all records pushed up to that point are preserved in the dataset.

Compare this to a data entry contractor at $30/hour — at typical data entry speeds, manually creating 100 Pipedrive records with linked persons and deals takes 3-4 hours and costs $90-120. With this actor, the same batch costs $5.00 and runs in under 5 minutes.

### Push leads to Pipedrive using the API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/pipedrive-lead-pusher").call(run_input={
    "pipedriveApiToken": "YOUR_PIPEDRIVE_TOKEN",
    "pipedriveCompanyDomain": "acmesales",
    "datasetId": "YOUR_UPSTREAM_DATASET_ID",
    "createOrganizations": True,
    "createPersons": True,
    "createDeals": True,
    "skipDuplicateOrgs": True,
    "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
    "minIcpScore": 60,
    "dryRun": False,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "summary":
        print(f"Run complete: {item['orgsCreated']} orgs, {item['personsCreated']} persons, {item['dealsCreated']} deals")
    elif item.get("status") == "error":
        print(f"Error on {item['companyName']}: {item['errors']}")
    else:
        org_id = item.get("organization", {}).get("id")
        print(f"{item['companyName']} → org #{org_id}, status: {item['status']}")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/pipedrive-lead-pusher").call({
    pipedriveApiToken: "YOUR_PIPEDRIVE_TOKEN",
    pipedriveCompanyDomain: "acmesales",
    datasetId: "YOUR_UPSTREAM_DATASET_ID",
    createOrganizations: true,
    createPersons: true,
    createDeals: true,
    skipDuplicateOrgs: true,
    dealTitle: "New Lead: {{companyName}} (Score: {{icpScore}})",
    minIcpScore: 60,
    dryRun: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    if (item.type === "summary") {
        console.log(`Complete: ${item.orgsCreated} orgs, ${item.personsCreated} persons, ${item.dealsCreated} deals`);
    } else if (item.status === "success") {
        console.log(`${item.companyName} → org #${item.organization?.id}, ${item.persons?.length} person(s)`);
    }
}
```

#### cURL

```bash
## Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~pipedrive-lead-pusher/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "pipedriveApiToken": "YOUR_PIPEDRIVE_TOKEN",
    "pipedriveCompanyDomain": "acmesales",
    "createOrganizations": true,
    "createPersons": true,
    "createDeals": false,
    "skipDuplicateOrgs": true,
    "minIcpScore": 60,
    "dryRun": false,
    "leads": [
      {
        "companyName": "Redwood Logistics",
        "domain": "redwoodlogistics.com",
        "city": "Portland",
        "country": "United States",
        "contacts": [{ "name": "Dana Park", "email": "dana@redwoodlogistics.com", "title": "CEO" }],
        "icpScore": 78
      }
    ]
  }'

## Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"
```

### How Pipedrive Lead Pusher works

#### Lead loading and pre-filtering

The actor accepts leads from two sources: a JSON array passed directly in the `leads` input field, or up to 1,000 items fetched from an Apify dataset via the `datasetId` field using `Actor.apifyClient.dataset(id).listItems()`. After loading, the ICP score filter runs first — leads where `icpScore` (or `score`) falls below `minIcpScore` are discarded before any Pipedrive API calls occur, saving both time and cost.

#### Field mapping

Three mapper functions transform each Lead object into Pipedrive API payloads. `mapLeadToOrganization` builds the org payload from `companyName`, `domain`/`website`, and address components joined with commas. `mapLeadToPersons` deduplicates across `contacts[]`, `emails[]`, and `email` by email address (lowercased), producing one `PipedrivePersonPayload` per unique address — structured contacts take priority and carry name, job title, and phone; standalone email addresses fall back to a `"CompanyName Contact"` display name. `mapLeadToDeal` renders the `dealTitle` template string using a `{{variable}}` regex replace against a per-lead variable map covering `companyName`, `domain`, `icpScore`, `icpGrade`, `city`, `country`, and `industry`.

#### Sequential API creates with deduplication

Pipedrive has no batch create endpoint and enforces a 10 req/s rate limit. The actor processes leads sequentially with a 200ms pause between each lead and a 100ms pause between persons within a single lead. Before creating an organization, the actor calls `/organizations/search?term={name}&limit=1` — if a result is returned, the existing org ID is reused for person and deal linking instead of creating a duplicate. The Pipedrive v2 API client handles 429 responses with exponential backoff (2s, 4s, 8s) for up to 3 retries, and similarly backs off on 5xx errors with 1s, 2s, 4s intervals.

#### Status tracking and output assembly

Each lead produces one output record immediately after processing (before the PPE charge fires). The overall `status` field is derived from the combination of sub-results: `success` if all attempted creates succeeded; `partial` if at least one succeeded and at least one failed; `error` if all required creates failed. In dry-run mode, all payloads are mapped and returned as `dry_run` status records with null IDs — the exact same code paths execute, but no HTTP requests are sent to Pipedrive. The final record in every run is a typed `summary` object aggregating all counters.

### Tips for best results

1. **Run dry first on every new data source.** The dry-run output shows the exact `name`, `address`, `email`, and `job_title` values that would be sent to Pipedrive. Check for garbled company names derived from unusual domains, missing contacts, or address formatting issues before committing.

2. **Use `datasetId` chaining for fully automated pipelines.** Trigger this actor via webhook immediately after [B2B Lead Gen Suite](https://apify.com/ryanclinton/b2b-lead-gen-suite) or [Waterfall Contact Enrichment](https://apify.com/ryanclinton/waterfall-contact-enrichment) completes. Pass the upstream run's `defaultDatasetId` as input — no file exports or intermediate storage required.

3. **Keep `skipDuplicateOrgs: true` for ongoing sync operations.** When running regular imports against a CRM that already contains companies, dedup search prevents accumulating duplicate organization records. The matched org ID is used to correctly link new persons to the existing company.

4. **Set `minIcpScore` to control Pipedrive data quality.** Pushing every scraped lead into a CRM degrades pipeline hygiene. A threshold of 60-70 on scored output from [B2B Lead Qualifier](https://apify.com/ryanclinton/b2b-lead-qualifier) keeps your Pipedrive focused on genuinely qualified prospects.

5. **Use deal title templates to add campaign context.** The template `"{{companyName}} — Q2 Outbound ({{city}})"` makes deals instantly identifiable by campaign and geography inside Pipedrive, which matters when multiple reps work the same pipeline.

6. **Find your `dealStageId` before going live.** Call `GET https://api.apify.com` — or use Pipedrive's own API explorer at `https://YOUR_DOMAIN.pipedrive.com/api/v2/stages` — to list stage IDs for your pipeline. Leaving this blank places deals in stage 1 of your default pipeline.

7. **Check the summary record for run health.** The final dataset item has `type: "summary"` and gives you orgs created, persons created, dedup skips, score-filtered leads, and error counts at a glance. If `errors > 0`, filter the dataset on `status === "error"` to see exactly which companies failed and why.

8. **Split very large lists across runs.** The actor loads up to 1,000 dataset items per run. For lists larger than 1,000, use Apify's dataset pagination or the `limit`/`offset` parameters to process in batches, or contact Apify support for high-volume arrangements.

### Combine with other Apify actors

| Actor | How to combine |
|---|---|
| [B2B Lead Gen Suite](https://apify.com/ryanclinton/b2b-lead-gen-suite) | Full pipeline: URLs → scored, enriched leads → push to Pipedrive in one chained workflow. Pass the output `datasetId` directly to this actor. |
| [B2B Lead Qualifier](https://apify.com/ryanclinton/b2b-lead-qualifier) | Score leads 0–100 before pushing. Set `minIcpScore: 65` here to filter only qualified prospects into Pipedrive. |
| [Website Contact Scraper](https://apify.com/ryanclinton/website-contact-scraper) | Scrape emails and phones from company websites, then push the enriched contact data here to populate Pipedrive persons with real contact details. |
| [Google Maps Email Extractor](https://apify.com/ryanclinton/google-maps-email-extractor) | Extract local business contacts from Google Maps searches and push them into Pipedrive as organizations with linked person records. |
| [Waterfall Contact Enrichment](https://apify.com/ryanclinton/waterfall-contact-enrichment) | Run multi-source contact enrichment on a domain list, then push the verified emails and names into Pipedrive as fully-formed person records. |
| [Email Pattern Finder](https://apify.com/ryanclinton/email-pattern-finder) | Detect company email conventions (e.g. `first.last@domain.com`), construct contact emails, then sync into Pipedrive via this actor. |
| [HubSpot Lead Pusher](https://apify.com/ryanclinton/hubspot-lead-pusher) | The equivalent actor for HubSpot CRM. Run both in parallel if your team uses both CRMs. |

### Limitations

- **Maximum 1,000 leads per run from a dataset.** The actor calls `listItems({ limit: 1000 })`. For larger datasets, process in batches or use multiple runs with different dataset slices.
- **No update of existing records.** The actor only creates new organizations and persons. It does not update existing Pipedrive records with new field values. If a duplicate org is found, it is reused for linking but its fields (address, website) are not updated.
- **No Pipedrive OAuth support.** Authentication uses personal API tokens only. OAuth app integrations are not supported.
- **Organization dedup is name-only.** The search uses the organization name as the dedup key. Companies with the same name in different regions may be incorrectly merged. Consider disabling `skipDuplicateOrgs` if your list has legitimately distinct companies sharing a common name.
- **Person dedup is not performed.** If you push the same lead twice (e.g. from two separate runs), persons with the same email will be created twice. Pipedrive does not currently allow pre-creation dedup search on persons via API v2.
- **Dry-run leads are billed.** PPE charges of $0.05/lead apply in both dry-run and live modes. Dry run is free only if you have no API token provided and no PPE pricing has been configured.
- **No support for Pipedrive custom fields.** The actor maps to standard Pipedrive fields only (`name`, `address`, `web`, `email`, `phone`, `job_title`, `stage_id`). Pushing data to custom fields requires a custom integration.
- **Rate limit: 10 req/s.** Very large runs with many contacts per lead can approach Pipedrive's rate limit. The 200ms inter-lead delay and 100ms inter-person delay provide headroom, but unusually contact-rich leads may still encounter occasional 429 responses (handled with backoff).

### Integrations

- [Zapier](https://apify.com/integrations/zapier) — trigger this actor automatically from a Zapier workflow when a new lead is added to a Google Sheet or CRM
- [Make](https://apify.com/integrations/make) — build a Make scenario that chains web scraping with this actor and then notifies your Slack channel when Pipedrive records are created
- [Google Sheets](https://apify.com/integrations/google-sheets) — export the actor's output dataset to Google Sheets as a push log showing which organizations and persons were created per run
- [Apify API](https://docs.apify.com/api/v2) — call the actor programmatically from your own application to sync leads on demand as part of an internal workflow
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — configure a webhook to trigger this actor when any upstream scraping actor completes, creating a fully automated pipeline
- [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — feed AI-generated company research summaries from [Company Deep Research](https://apify.com/ryanclinton/company-deep-research) into this actor to populate Pipedrive with AI-enriched prospect data

### Troubleshooting

**"Pipedrive API token is invalid" error despite entering the correct token.** Verify you are using a personal API token (not an OAuth client secret). In Pipedrive, go to Settings > Personal preferences > API. Also confirm the `pipedriveCompanyDomain` matches your actual subdomain exactly — `acme` not `acme.pipedrive.com`. Token validation calls `/users/me` on startup and fails fast if either value is wrong.

**Organizations are being created as duplicates despite `skipDuplicateOrgs: true`.** The dedup search requires the company name to be at least 2 characters and performs a fuzzy name match. Companies with very short names (e.g. "AB") or names that differ by punctuation (e.g. "Acme Corp" vs "Acme Corp.") may not match. Check the `organization.status` field in the output — `created` means no match was found; `skipped_duplicate` means the existing ID was reused.

**Persons are missing from the output despite the lead having emails.** The actor reads from `contacts[].email`, `emails[]`, and `email` fields. If your lead data stores contacts under a different key name (e.g. `contactList` or `people`), the mapper will not find them. Reshape your input data to use the supported field names before running.

**Run is slow with many contacts per lead.** Each person creation is a separate API call. A lead with 5 unique email addresses makes 5 POST requests to `/persons` with a 100ms delay between each. For leads with many contacts, this is expected behavior. The 200ms inter-lead delay does not apply within a single lead's person creation loop.

**`status: "partial"` on some records.** This means at least one create succeeded and at least one failed within the same lead. Inspect the `errors[]` array on those records for specific Pipedrive error messages. Common causes: malformed email addresses, required Pipedrive fields that differ between account configurations, or a deal stage ID that does not exist in the target pipeline.

### Responsible use

- This actor only pushes data you have collected and own the rights to use.
- Ensure you have a legitimate business reason and proper consent basis under GDPR, CAN-SPAM, and other applicable laws before storing personal data (names, emails, phone numbers) in your CRM.
- Do not use this actor to import data obtained through unauthorized scraping of platforms that prohibit it in their terms of service.
- Respect data subject rights — if a contact requests deletion under GDPR, remove them from Pipedrive and from the source dataset.
- For guidance on web scraping legality, see [Apify's guide](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How do I push leads into Pipedrive from another Apify actor automatically?** Run the upstream actor (e.g. [B2B Lead Gen Suite](https://apify.com/ryanclinton/b2b-lead-gen-suite)) and copy the `defaultDatasetId` from its run page. Enter that ID in the `datasetId` field here. For full automation, use an Apify webhook to trigger this actor when the upstream run finishes — no manual steps required.

**Does Pipedrive Lead Pusher prevent duplicate organizations from being created?** Yes, when `skipDuplicateOrgs` is enabled (the default), the actor calls Pipedrive's `/organizations/search` API before each create. If a matching org name is found, its existing ID is used to link persons and deals — no new org is created. Persons are not deduplicated; the same email can be created twice if the actor is run multiple times with overlapping data.

**How many leads can I push in one run?** Up to 1,000 leads from a dataset, or as many as you include in the inline `leads` array. For larger volumes, split into multiple runs. Processing speed depends on contacts per lead — a batch of 100 leads with 2 contacts each typically completes in under 5 minutes.

**Is it legal to import scraped contact data into a CRM?** Whether data collection was legal depends on your jurisdiction and the data source. Storing personal data in a CRM is subject to GDPR, CAN-SPAM, and equivalent laws. You should have a lawful basis for processing (e.g. legitimate interest for B2B prospecting) and maintain opt-out mechanisms. See [Apify's legal guide](https://blog.apify.com/is-web-scraping-legal/) for detailed guidance.

**What happens if my Pipedrive API token expires or becomes invalid mid-run?** The actor validates the token at startup via `/users/me`. If validation fails, the run stops immediately with an error message before processing any leads. If the token becomes invalid during a run (rare but possible), individual API calls return HTTP 401 errors captured in the `errors[]` field of each affected lead record.

**Can I push leads into multiple Pipedrive accounts?** Not in a single run. Each run is configured for one Pipedrive company domain and one API token. To push into multiple accounts, run the actor once per account with different `pipedriveApiToken` and `pipedriveCompanyDomain` values.

**How is this different from Pipedrive's built-in CSV import?** Pipedrive's CSV import requires manual field mapping, does not link persons to organizations automatically, has no API-level deduplication, and requires you to format and upload a file every time. This actor is fully API-driven, supports programmatic triggering, chains directly with other actors via dataset IDs, and produces a structured audit log of every created record.

**Can I create deals without creating organizations or persons?** No. Deal creation requires at least an organization ID or person ID to be meaningful in Pipedrive. Enable `createOrganizations` or `createPersons` (or both) alongside `createDeals` to produce properly linked deals. If org creation fails for a lead, the deal will still be attempted but will have no `org_id`.

**What fields can I use in the deal title template?** The template supports `{{companyName}}`, `{{domain}}`, `{{icpScore}}`, `{{icpGrade}}`, `{{city}}`, `{{country}}`, and `{{industry}}`. Unknown variables are left as-is (e.g. `{{unknown}}` stays literal). Example: `"Inbound Lead: {{companyName}} — {{city}}, {{country}} (Grade: {{icpGrade}})"`.

**How long does a typical run take?** A batch of 100 leads with `createOrganizations: true`, `createPersons: true`, and `createDeals: true` takes approximately 2-4 minutes, depending on the number of contacts per lead and Pipedrive API response times. The 200ms inter-lead delay means 100 leads take at least 20 seconds of enforced pacing alone.

**Can I schedule this actor to run automatically?** Yes. Use Apify's built-in scheduler to run on any cron schedule — daily, weekly, or custom intervals. Combine with a webhook from an upstream actor to create a fully event-driven pipeline where new scraped leads flow into Pipedrive automatically.

**What does `status: "partial"` mean in the output?** Partial means at least one Pipedrive record was created successfully for that lead, but at least one other failed. For example, the organization was created but a person's email was rejected by Pipedrive as invalid. Check the `errors[]` array on the record for the specific failure message.

### Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to [Account Settings > Privacy](https://console.apify.com/account/privacy)
2. Enable **Share runs with public Actor creators**

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

### Support

Found a bug or have a feature request? Open an issue in the [Issues tab](https://console.apify.com/actors/pipedrive-lead-pusher/issues) on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.

# Actor input Schema

## `pipedriveApiToken` (type: `string`):

Your Pipedrive personal API token. Find it at: Settings > Personal preferences > API. Leave empty for dry-run preview mode.

## `pipedriveCompanyDomain` (type: `string`):

Your Pipedrive subdomain (e.g. 'acme' for acme.pipedrive.com). Required.

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

Lead objects to push to Pipedrive. Each should have at least a companyName or domain. Supports output from B2B Lead Gen Suite, Lead Scoring Engine, or custom data.

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

Apify dataset ID to pull leads from (alternative to inline leads). Use this to chain with B2B Lead Gen Suite, Lead Scoring Engine, or other pipeline actors.

## `createOrganizations` (type: `boolean`):

Create Pipedrive organization records from lead company names and domains.

## `createPersons` (type: `boolean`):

Create Pipedrive person records from lead contacts and emails, linked to their organization.

## `createDeals` (type: `boolean`):

Create a Pipedrive deal for each lead, linked to the organization and first person.

## `skipDuplicateOrgs` (type: `boolean`):

Search Pipedrive for an existing organization with the same name before creating a new one. Prevents duplicates. Recommended.

## `dealTitle` (type: `string`):

Template for deal titles. Use {{companyName}}, {{domain}}, {{icpScore}}, {{icpGrade}}, {{city}}, {{country}}, {{industry}} as placeholders.

## `dealStageId` (type: `integer`):

Pipedrive stage ID to assign new deals to. Find stage IDs at: Settings > Pipeline. Leave empty to use default stage.

## `minIcpScore` (type: `integer`):

Only push leads with an icpScore (or score) at or above this threshold. Set to 0 or leave empty to push all leads.

## `dryRun` (type: `boolean`):

Preview mapped Pipedrive data without actually pushing records. Use this to verify field mapping before committing. Automatically enabled when no API token is provided.

## Actor input object example

```json
{
  "pipedriveCompanyDomain": "yourcompany",
  "leads": [
    {
      "domain": "growthagency.io",
      "companyName": "Growth Agency",
      "city": "Austin",
      "state": "TX",
      "country": "United States",
      "industry": "Marketing & Advertising",
      "emails": [
        "hello@growthagency.io"
      ],
      "contacts": [
        {
          "name": "Sarah Chen",
          "title": "Founder",
          "email": "sarah@growthagency.io",
          "phone": "+1-512-555-0192"
        }
      ],
      "icpScore": 82,
      "icpGrade": "A"
    }
  ],
  "createOrganizations": true,
  "createPersons": true,
  "createDeals": false,
  "skipDuplicateOrgs": true,
  "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
  "dryRun": true
}
```

# 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 = {
    "pipedriveCompanyDomain": "yourcompany",
    "leads": [
        {
            "domain": "growthagency.io",
            "companyName": "Growth Agency",
            "city": "Austin",
            "state": "TX",
            "country": "United States",
            "industry": "Marketing & Advertising",
            "emails": [
                "hello@growthagency.io"
            ],
            "contacts": [
                {
                    "name": "Sarah Chen",
                    "title": "Founder",
                    "email": "sarah@growthagency.io",
                    "phone": "+1-512-555-0192"
                }
            ],
            "icpScore": 82,
            "icpGrade": "A"
        }
    ],
    "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
    "dryRun": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/pipedrive-lead-pusher").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 = {
    "pipedriveCompanyDomain": "yourcompany",
    "leads": [{
            "domain": "growthagency.io",
            "companyName": "Growth Agency",
            "city": "Austin",
            "state": "TX",
            "country": "United States",
            "industry": "Marketing & Advertising",
            "emails": ["hello@growthagency.io"],
            "contacts": [{
                    "name": "Sarah Chen",
                    "title": "Founder",
                    "email": "sarah@growthagency.io",
                    "phone": "+1-512-555-0192",
                }],
            "icpScore": 82,
            "icpGrade": "A",
        }],
    "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
    "dryRun": True,
}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/pipedrive-lead-pusher").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 '{
  "pipedriveCompanyDomain": "yourcompany",
  "leads": [
    {
      "domain": "growthagency.io",
      "companyName": "Growth Agency",
      "city": "Austin",
      "state": "TX",
      "country": "United States",
      "industry": "Marketing & Advertising",
      "emails": [
        "hello@growthagency.io"
      ],
      "contacts": [
        {
          "name": "Sarah Chen",
          "title": "Founder",
          "email": "sarah@growthagency.io",
          "phone": "+1-512-555-0192"
        }
      ],
      "icpScore": 82,
      "icpGrade": "A"
    }
  ],
  "dealTitle": "New Lead: {{companyName}} (Score: {{icpScore}})",
  "dryRun": true
}' |
apify call ryanclinton/pipedrive-lead-pusher --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pipedrive Lead Pusher — Sync Leads to CRM",
        "description": "Syncs scraped leads into Pipedrive CRM as organizations, persons, and deals. Duplicate detection, ICP score filtering, dry-run preview, and dataset chaining from any Apify actor. $0.05/lead.",
        "version": "1.0",
        "x-build-id": "9EkwMCnfHvLqtEgNV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~pipedrive-lead-pusher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-pipedrive-lead-pusher",
                "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/ryanclinton~pipedrive-lead-pusher/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-pipedrive-lead-pusher",
                "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/ryanclinton~pipedrive-lead-pusher/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-pipedrive-lead-pusher",
                "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": [
                    "pipedriveCompanyDomain"
                ],
                "properties": {
                    "pipedriveApiToken": {
                        "title": "Pipedrive API Token",
                        "type": "string",
                        "description": "Your Pipedrive personal API token. Find it at: Settings > Personal preferences > API. Leave empty for dry-run preview mode."
                    },
                    "pipedriveCompanyDomain": {
                        "title": "Pipedrive Company Domain",
                        "type": "string",
                        "description": "Your Pipedrive subdomain (e.g. 'acme' for acme.pipedrive.com). Required.",
                        "default": "yourcompany"
                    },
                    "leads": {
                        "title": "Leads (inline data)",
                        "type": "array",
                        "description": "Lead objects to push to Pipedrive. Each should have at least a companyName or domain. Supports output from B2B Lead Gen Suite, Lead Scoring Engine, or custom data.",
                        "default": [
                            {
                                "domain": "growthagency.io",
                                "companyName": "Growth Agency",
                                "city": "Austin",
                                "state": "TX",
                                "country": "United States",
                                "industry": "Marketing & Advertising",
                                "emails": [
                                    "hello@growthagency.io"
                                ],
                                "contacts": [
                                    {
                                        "name": "Sarah Chen",
                                        "title": "Founder",
                                        "email": "sarah@growthagency.io",
                                        "phone": "+1-512-555-0192"
                                    }
                                ],
                                "icpScore": 82,
                                "icpGrade": "A"
                            }
                        ]
                    },
                    "datasetId": {
                        "title": "Apify Dataset ID",
                        "type": "string",
                        "description": "Apify dataset ID to pull leads from (alternative to inline leads). Use this to chain with B2B Lead Gen Suite, Lead Scoring Engine, or other pipeline actors."
                    },
                    "createOrganizations": {
                        "title": "Create organizations",
                        "type": "boolean",
                        "description": "Create Pipedrive organization records from lead company names and domains.",
                        "default": true
                    },
                    "createPersons": {
                        "title": "Create persons",
                        "type": "boolean",
                        "description": "Create Pipedrive person records from lead contacts and emails, linked to their organization.",
                        "default": true
                    },
                    "createDeals": {
                        "title": "Create deals",
                        "type": "boolean",
                        "description": "Create a Pipedrive deal for each lead, linked to the organization and first person.",
                        "default": false
                    },
                    "skipDuplicateOrgs": {
                        "title": "Skip duplicate organizations",
                        "type": "boolean",
                        "description": "Search Pipedrive for an existing organization with the same name before creating a new one. Prevents duplicates. Recommended.",
                        "default": true
                    },
                    "dealTitle": {
                        "title": "Deal title template",
                        "type": "string",
                        "description": "Template for deal titles. Use {{companyName}}, {{domain}}, {{icpScore}}, {{icpGrade}}, {{city}}, {{country}}, {{industry}} as placeholders.",
                        "default": "New Lead: {{companyName}}"
                    },
                    "dealStageId": {
                        "title": "Deal stage ID",
                        "type": "integer",
                        "description": "Pipedrive stage ID to assign new deals to. Find stage IDs at: Settings > Pipeline. Leave empty to use default stage."
                    },
                    "minIcpScore": {
                        "title": "Minimum ICP score filter",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only push leads with an icpScore (or score) at or above this threshold. Set to 0 or leave empty to push all leads."
                    },
                    "dryRun": {
                        "title": "Dry run (preview only)",
                        "type": "boolean",
                        "description": "Preview mapped Pipedrive data without actually pushing records. Use this to verify field mapping before committing. Automatically enabled when no API token is provided.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```