Skip to main content

Batch Result

Retrieves the enriched contact data for a previously submitted batch request from Dropcontact.

Common Properties​

  • Name - The custom name of the node.
  • Color - The custom color of the node.
  • Delay Before (sec) - Waits in seconds before executing the node.
  • Delay After (sec) - Waits in seconds after executing node.
  • Continue On Error - Automation will continue regardless of any error. The default value is false.
info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Inputs​

  • Request ID - The request ID string returned from the Batch Post node. This identifies which batch results to retrieve.

Options​

  • API Key - Dropcontact API key for authentication (credential type).

Output​

  • result - An object containing the enriched contact data returned by Dropcontact, including email addresses, phone numbers, company information, and other enriched fields.

How It Works​

The Batch Result node retrieves enrichment results for a previously submitted batch. When executed, the node:

  1. Validates the request ID is not empty
  2. Constructs a GET request to the Dropcontact API endpoint
  3. Adds authentication headers with the API key
  4. Sends the request to https://api.dropcontact.io/batch/{request_id}
  5. Parses the JSON response containing enriched contact data
  6. Returns the complete result object

Requirements​

  • A valid Dropcontact account with API access
  • API key configured in credentials
  • A valid request ID from a previous Batch Post operation
  • Sufficient time elapsed for Dropcontact to process the batch (typically 30-60 seconds)

Error Handling​

The node will return specific errors in the following cases:

  • ErrInvalidArg - Request ID is empty or missing
  • ErrCredentials - Failed to retrieve API key from credentials
  • ErrInternal - Failed to create HTTP request
  • ErrRuntime - Failed to send request or parse response

Usage Notes​

  • Wait at least 30-60 seconds after submitting a batch before retrieving results
  • The result object includes processing status information
  • You can poll this node multiple times with the same request ID
  • Results remain available for retrieval for a reasonable time period
  • The API may return partial results if processing is still in progress
  • Check the response status to determine if processing is complete

Result Object Structure​

The result object contains comprehensive enriched data for all contacts in the batch:

{
  "success": true,
  "error": false,
  "request_id": "abc123def456",
  "total_count": 3,
  "processed_count": 3,
  "data": [
    {
      "civility": "M",
      "first_name": "John",
      "last_name": "Doe",
      "full_name": "John Doe",
      "email": [
        {
          "email": "john.doe@acmecorp.com",
          "qualification": "verified",
          "is_the_most_complete_email": true
        }
      ],
      "phone": "+1234567890",
      "mobile_phone": "+1987654321",
      "company": "Acme Corp",
      "website": "https://acmecorp.com",
      "linkedin": "https://www.linkedin.com/in/johndoe/",
      "company_linkedin": "https://www.linkedin.com/company/acme-corp/",
      "nb_employees": "51-200",
      "siren": "123456789",
      "siret": "12345678900012",
      "naf5_code": "6201Z",
      "company_country": "United States",
      "company_city": "New York",
      "company_address": "123 Main Street",
      "job_title": "Senior Product Manager"
    }
  ]
}

Response Fields​

Top-level Fields:

  • success - Boolean indicating if the request was successful
  • error - Boolean indicating if errors occurred
  • request_id - The original request ID
  • total_count - Total number of contacts in the batch
  • processed_count - Number of contacts processed so far
  • data - Array of enriched contact objects

Contact Object Fields:

  • civility - Title (M, Ms, etc.)
  • first_name - Verified first name
  • last_name - Verified last name
  • full_name - Complete name
  • email - Array of email objects with qualification status
  • phone - Company phone number
  • mobile_phone - Mobile phone number
  • company - Verified company name
  • website - Company website URL
  • linkedin - Contact's LinkedIn profile
  • company_linkedin - Company's LinkedIn page
  • nb_employees - Employee count range
  • siren/siret - French company identifiers (if requested)
  • naf5_code - French business activity code
  • company_country - Company headquarters country
  • company_city - Company city
  • company_address - Company address
  • job_title - Contact's job position

Example: Basic Result Retrieval​

Input:

request_id: "abc123def456ghi789jkl"

Flow Setup:

  1. Batch Post node submits contacts and outputs request_id
  2. Delay node waits 45 seconds
  3. Batch Result node retrieves enriched data
  4. Log node displays the results

Output: The result object containing all enriched contact information for the submitted batch.

Example: Processing Loop with Status Check​

This example shows how to poll for results until processing is complete:

1. Batch Post → Store request_id in variable
2. Delay 30 seconds
3. Loop Start (max 10 iterations)
   ├─ Batch Result → Get results
   ├─ Check if processed_count = total_count
   ├─ If complete → Break loop
   └─ If not → Delay 15 seconds, continue loop
4. Process enriched data

Tips:

  • Check processed_count vs total_count to verify completion
  • Implement exponential backoff for polling (e.g., 15s, 30s, 60s)
  • Store partial results if needed before processing completes

Example: Enrich and Update CRM​

This complete workflow enriches contacts and updates a CRM:

  1. Read CSV - Load contacts needing enrichment
  2. Loop - Process in batches of 250
  3. Object - Build batch data object
  4. Batch Post - Submit for enrichment
  5. Store - Save request_id to data table
  6. Delay - Wait 60 seconds
  7. Batch Result - Retrieve enriched data
  8. Loop Results - Iterate through enriched contacts
  9. Update CRM - Update contact records with enriched data
  10. Log - Record successful updates

Data Extraction Example:

// Extract verified emails from result
let contacts = $.result.data;
for (let contact of contacts) {
  if (contact.email && contact.email.length > 0) {
    let verifiedEmail = contact.email.find(e => e.qualification === "verified");
    if (verifiedEmail) {
      console.log(`Found email: ${verifiedEmail.email} for ${contact.full_name}`);
    }
  }
}

Example: Filter and Export Verified Contacts​

This workflow filters contacts with verified emails and exports them:

  1. Batch Result - Retrieve enriched data
  2. JavaScript - Filter contacts with verified emails:
let verified = $.result.data.filter(contact => {
  return contact.email && contact.email.some(e => e.qualification === "verified");
});
return { verified_contacts: verified };
  1. Excel - Export verified contacts to spreadsheet
  2. Mail - Send notification with export file

Understanding Email Qualification​

Dropcontact returns email arrays with qualification statuses:

  • verified - Email confirmed as valid and deliverable
  • probable - Email likely valid but not verified
  • impossible - Email structure valid but domain/mailbox doesn't exist
  • catch-all - Server accepts all emails (cannot verify specific address)

Best Practice:

// Prioritize email selection
let bestEmail = null;
if (contact.email && contact.email.length > 0) {
  // First try verified
  bestEmail = contact.email.find(e => e.qualification === "verified");
  // Fall back to most complete email
  if (!bestEmail) {
    bestEmail = contact.email.find(e => e.is_the_most_complete_email);
  }
  // Last resort: first email
  if (!bestEmail) {
    bestEmail = contact.email[0];
  }
}

Common Errors and Solutions​

Error: "Request ID cannot be empty"​

Cause: The request ID input is missing or empty Solution:

  • Verify the Batch Post node successfully executed and returned a request_id
  • Check that the request_id variable is properly passed to this node
  • Ensure the request_id value is stored in message scope

Error: "Failed to send request"​

Cause: Network connectivity issues or API endpoint unreachable Solution:

  • Verify internet connectivity
  • Check firewall settings allow HTTPS requests to dropcontact.io
  • Retry after a brief delay

Error: "Failed to parse response"​

Cause: API returned invalid JSON or unexpected response format Solution:

  • Verify the request ID is valid and from a real Batch Post operation
  • Check that the batch request hasn't expired (results are kept for a limited time)
  • Ensure you're using the correct API key that submitted the batch

No data or empty results​

Cause: Processing not yet complete or contacts didn't match Solution:

  • Wait longer before retrieving results (60+ seconds for large batches)
  • Check that submitted contacts had valid data combinations
  • Verify contacts exist in business databases (B2B focus)
  • Review the input data quality from the original Batch Post

Best Practices​

  1. Timing: Wait at least 30-60 seconds after Batch Post before retrieving results
  2. Polling Strategy: Use exponential backoff (30s, 60s, 120s) if implementing retry logic
  3. Status Checks: Always verify processed_count equals total_count before final processing
  4. Error Handling: Enable Continue On Error for resilient automation flows
  5. Email Selection: Implement logic to prioritize verified emails over probable ones
  6. Data Validation: Check for null/empty values before using enriched fields
  7. Result Storage: Save complete results to database or file for audit trails
  8. Partial Processing: Handle scenarios where some contacts enrich successfully and others don't
  9. Rate Limits: Don't poll too frequently - respect API rate limits (60 requests/second max)
  10. Credit Tracking: Monitor which contacts consumed credits (those with found/verified emails)

Processing Status Indicators​

Monitor these fields to track batch processing:

// Check if processing is complete
if ($.result.processed_count === $.result.total_count) {
  console.log("Batch processing complete!");
} else {
  console.log(`Still processing: ${$.result.processed_count}/${$.result.total_count}`);
}

// Check for errors
if ($.result.error) {
  console.log("Batch processing encountered errors");
}

Working with Large Batches​

For processing large contact lists (1000+ contacts):

  1. Split into batches of 250 contacts
  2. Submit each batch with Batch Post (store all request_ids)
  3. Wait 60 seconds
  4. Retrieve results for all batches in parallel
  5. Merge results into single dataset
  6. Process consolidated enriched data

Example Structure:

For each batch of 250:
  - Batch Post → request_id_1, request_id_2, ...
  - Store in array: [request_id_1, request_id_2, ...]

Delay 60 seconds

For each request_id in array:
  - Batch Result → Append to results array

Combine all results → Final enriched dataset