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?

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 or 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, 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 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

*Either leads or datasetId must be provided.

Input examples

Dry-run preview with inline leads (most common starting point):

{
    "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": "[email protected]",
                    "phone": "+1-720-555-0134"
                }
            ]
        }
    ]
}

Live push from dataset with deal creation and score filter:

{
    "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:

{
    "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 or 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

{
    "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": "[email protected]",
            "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):

{
    "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

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.

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

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

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

# 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": "[email protected]", "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 or 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 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

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 — trigger this actor automatically from a Zapier workflow when a new lead is added to a Google Sheet or CRM
• 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 — export the actor's output dataset to Google Sheets as a push log showing which organizations and persons were created per run
• Apify API — call the actor programmatically from your own application to sync leads on demand as part of an internal workflow
• Webhooks — configure a webhook to trigger this actor when any upstream scraping actor completes, creating a fully automated pipeline
• LangChain / LlamaIndex — feed AI-generated company research summaries from 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.

FAQ

How do I push leads into Pipedrive from another Apify actor automatically? Run the upstream actor (e.g. 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 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
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 on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.