Connect GetResponse with Salesforce

Implementation Guide

Overview: Connecting GetResponse and Salesforce

GetResponse is a marketing automation and email marketing platform positioned strongly in the SMB and mid-market segments, offering contact list management, automated email sequences (autoresponders), webinar hosting, landing pages, and basic CRM capabilities. Salesforce is the dominant enterprise CRM, serving as the system of record for pipeline management, account history, and revenue forecasting. Organisations that use GetResponse for outbound marketing and lead nurturing alongside Salesforce for sales execution face the same fundamental integration challenge: contacts and engagement data created in GetResponse need to be reflected accurately and promptly in Salesforce so that sales teams can act on marketing-qualified leads without delay.

The GetResponse-to-Salesforce integration creates a live bridge between these two systems. When a contact subscribes to a GetResponse list, opens a key email, registers for a webinar, or receives a specific tag from an automation rule, those signals are pushed into Salesforce as Lead record updates, Campaign Member additions, or Task creations. This guide provides a comprehensive implementation path, covering GetResponse's API and webhook architecture, Salesforce's REST API and OAuth mechanisms, field mapping considerations, and a complete troubleshooting reference.

Core Prerequisites

GetResponse Requirements:

  • A GetResponse account on the Email Marketing, Marketing Automation, or Ecommerce Marketing plan. The API and webhook capabilities described in this guide require a paid plan. GetResponse MAX (enterprise tier) includes additional API rate limit allowances.
  • An API Key generated in GetResponse under My Profile > Integrations & API > API. The GetResponse API v3 uses this key as a Bearer token. Note that GetResponse also supports OAuth 2.0 for third-party application integrations; for server-to-server integrations, the API key approach is simpler and equally secure when stored properly.
  • Familiarity with GetResponse's core data model: Contacts (individual subscriber records), Lists (equivalent to Audiences or Segments — each contact belongs to one or more lists), Tags (labels applied to contacts via automation rules or manual tagging), Custom Fields (additional data fields beyond the standard profile), and Campaigns (GetResponse uses "campaign" to mean an email list/audience, which is different from Salesforce's Campaign object — this naming conflict is a frequent source of confusion).
  • GetResponse's Callbacks feature (their term for webhooks) must be enabled. Callbacks are configured via the API (POST https://api.getresponse.com/v3/callbacks) rather than through a UI panel, which means initial setup requires programmatic API access.
  • If using GetResponse MAX, the API endpoint base URL differs: use https://api3.getresponse360.com/v3 instead of https://api.getresponse.com/v3.

Salesforce Requirements:

  • A Salesforce org with System Administrator profile, or a user with API Enabled, Create and Edit on Lead, Create and Edit on Task, Create and Edit on CampaignMember, and Read on Campaign.
  • A Connected App in Salesforce configured for OAuth 2.0. For production server-to-server use, configure the Connected App for JWT Bearer Token Flow (requires uploading an X.509 certificate) or Client Credentials Flow (available in Salesforce API version 53.0 and later, requiring the Connected App to have the client_credentials OAuth grant type enabled and a Run As user assigned).
  • The Salesforce Consumer Key, Consumer Secret, and instance URL.
  • A clear understanding of your Salesforce Lead assignment rules. Leads created via API bypass the standard web-to-lead assignment rule process unless you explicitly call the Lead Assignment Rules endpoint or set the assignedToId field. Define and document your assignment logic before implementing the integration.
  • Custom Fields on the Salesforce Lead object to store GetResponse-specific data: GetResponse_List_ID__c (Text, 50), GetResponse_Contact_ID__c (Text, 50, marked as External ID for upsert operations), GetResponse_Tags__c (Text Area, 255), GetResponse_Last_Email_Opened__c (DateTime), and GetResponse_Subscription_Date__c (DateTime). Create these via Setup > Object Manager > Lead > Fields & Relationships.

Data Architecture Prerequisites:

  • A definitive mapping between GetResponse contact profile fields and Salesforce Lead fields. GetResponse standard fields include name (full name), email, dayOfBirth, address (complex object with street, city, state, zip, country), and any custom fields configured in your account. GetResponse's name field is a single string — you will need to split on the first space to populate Salesforce's separate FirstName and LastName fields, handling edge cases like single-word names, names with prefixes (Dr., Mr.), and multi-part last names.
  • A decision on whether to write GetResponse contacts to Salesforce as Leads (appropriate if they are not yet qualified) or to check for existing Contacts first and update them if found (appropriate for re-engagement campaigns targeting existing customers). Most implementations default to Lead creation with a deduplication check against both the Lead and Contact objects by email.

Top Enterprise Use Cases

1. Marketing Qualified Lead Synchronisation The baseline use case. When a contact subscribes to a GetResponse list associated with a marketing campaign (e.g., a content download, webinar registration, or newsletter sign-up), the integration creates a Salesforce Lead with the contact's profile data, maps the list name to a Lead Source value, and optionally adds the Lead to a corresponding Salesforce Campaign. This gives the sales team real-time visibility into new inbound leads from email marketing activities without waiting for manual exports.

2. Lead Scoring Signal Propagation via Tags GetResponse's marketing automation allows applying tags to contacts based on behavioural signals: email opens, link clicks, page visits, webinar attendance, and more. When a high-intent tag such as pricing_page_visited, demo_watched, or free_trial_started is applied to a GetResponse contact, the integration updates the corresponding Salesforce Lead's Rating field to Hot or increments a custom lead score field. This bridges GetResponse's implicit intent scoring with Salesforce's explicit lead qualification model.

3. Webinar Attendee Lead Generation GetResponse includes a built-in webinar platform. When a contact registers for a webinar, the integration creates a Salesforce Lead and adds them as a Campaign Member with Status: Registered. When the contact attends the live webinar (captured via GetResponse's attendee data, which can be queried post-webinar via the API), the Campaign Member status is updated to Attended, triggering Salesforce workflow rules that notify the assigned sales rep for post-webinar follow-up.

4. Unsubscribe and Opt-Out Compliance Synchronisation When a contact unsubscribes from a GetResponse list, the integration must immediately update the Salesforce Lead's HasOptedOutOfEmail field to true. Failure to do this creates a compliance risk under GDPR and CAN-SPAM: a sales rep who emails a Lead from Salesforce may be contacting someone who has explicitly opted out of communications. This use case is arguably the most compliance-critical aspect of the integration.

5. Email Engagement Logging as Salesforce Activities For contacts who open or click key emails in a GetResponse automation sequence, the integration logs an Activity (Task) on the corresponding Salesforce Lead. The Task subject records the email campaign name, the engagement type (Open or Click), and a timestamp. This populates the Lead's activity timeline in Salesforce, giving sales reps context on the prospect's engagement history before they make outbound contact.

Step-by-Step Implementation Guide

Phase 1: Authenticate with GetResponse and Register a Callback

GetResponse API v3 authentication uses the API key as a Bearer token. All API calls must include the header X-Auth-Token: api-key YOUR_API_KEY. To register a callback (webhook) that fires when a new subscriber is added to a specific list, make the following POST request. Replace YOUR_GETRESPONSE_API_KEY with your API key and abc123def with your GetResponse list ID (retrievable via GET https://api.getresponse.com/v3/campaigns):

curl -X POST https://api.getresponse.com/v3/callbacks \
  -H 'X-Auth-Token: api-key YOUR_GETRESPONSE_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://integrate.yourdomain.com/webhooks/getresponse",
    "actions": {
      "subscribe": true,
      "unsubscribe": true,
      "open": false,
      "click": false,
      "tag_applied": true
    },
    "campaigns": [
      {
        "campaignId": "abc123def"
      }
    ]
  }'

Note that GetResponse's subscribe action fires when a contact is added to the list, regardless of whether the subscription was opt-in confirmed or direct API import. The tag_applied action fires whenever a tag is assigned to a contact in the specified list.

A GetResponse callback POST payload for a subscribe event looks like the following:

{
  "contact": {
    "contactId": "xyz789abc",
    "email": "[email protected]",
    "name": "Jane Doe",
    "campaign": {
      "campaignId": "abc123def",
      "name": "Q2 2026 Nurture List"
    },
    "createdOn": "2026-04-21T09:15:00+0000",
    "tags": [
      { "tagId": "tag001", "name": "webinar_registrant" }
    ],
    "customFields": [
      {
        "customFieldId": "cf001",
        "name": "company",
        "value": ["Acme Corporation"]
      },
      {
        "customFieldId": "cf002",
        "name": "job_title",
        "value": ["VP of Engineering"]
      }
    ]
  },
  "action": "subscribe"
}

Parse this payload to extract contact.email, contact.name, contact.campaign.name, contact.createdOn, contact.contactId, and contact.customFields (which you will need to iterate over by name to retrieve specific field values).

Phase 2: Retrieve Extended Contact Data from GetResponse API

The callback payload does not always include the full contact profile, particularly for address fields and all custom field values. After receiving and acknowledging the callback with HTTP 200, fetch the complete contact record:

curl -X GET "https://api.getresponse.com/v3/contacts/xyz789abc?fields=email,name,address,customFields,tags,scoring,createdOn" \
  -H 'X-Auth-Token: api-key YOUR_GETRESPONSE_API_KEY'

The fields query parameter limits the response to only the data you need, reducing payload size and processing time.

Phase 3: Authenticate with Salesforce Using Client Credentials Flow

The Salesforce OAuth 2.0 Client Credentials Flow (introduced in API v53) is ideal for server-to-server integrations where no user interaction is possible. It is simpler to implement than JWT Bearer Flow. Once your Connected App is configured with this grant type and a Run As user is assigned, obtain an access token as follows:

curl -X POST https://login.salesforce.com/services/oauth2/token \
  -d 'grant_type=client_credentials' \
  -d 'client_id=YOUR_SF_CONSUMER_KEY' \
  -d 'client_secret=YOUR_SF_CONSUMER_SECRET'

The response contains access_token and instance_url. Use these for all subsequent Salesforce API calls.

Phase 4: Upsert the Salesforce Lead Using GetResponse Contact ID as External ID

Use the GetResponse_Contact_ID__c external ID field for upsert operations:

curl -X PATCH "https://your-org.my.salesforce.com/services/data/v59.0/sobjects/Lead/GetResponse_Contact_ID__c/xyz789abc" \
  -H 'Authorization: Bearer YOUR_SF_ACCESS_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "FirstName": "Jane",
    "LastName": "Doe",
    "Email": "[email protected]",
    "Company": "Acme Corporation",
    "Title": "VP of Engineering",
    "LeadSource": "Email Marketing",
    "Status": "Open - Not Contacted",
    "GetResponse_List_ID__c": "abc123def",
    "GetResponse_Tags__c": "webinar_registrant",
    "GetResponse_Subscription_Date__c": "2026-04-21T09:15:00Z",
    "HasOptedOutOfEmail": false
  }'

Salesforce returns HTTP 201 for new Lead creation and HTTP 204 for updates.

Phase 5: Handle Unsubscribe Events for Compliance

When the callback payload contains "action": "unsubscribe", immediately issue a Salesforce Lead update setting HasOptedOutOfEmail to true:

curl -X PATCH "https://your-org.my.salesforce.com/services/data/v59.0/sobjects/Lead/GetResponse_Contact_ID__c/xyz789abc" \
  -H 'Authorization: Bearer YOUR_SF_ACCESS_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "HasOptedOutOfEmail": true,
    "Status": "Unsubscribed"
  }'

Log this event with a timestamp in a custom Last_Unsubscribe_Date__c field on the Lead. If the contact exists as both a Lead and a Contact in Salesforce (e.g., after conversion), both records must be updated. Query for both Lead and Contact objects by email address and update HasOptedOutOfEmail on whichever records are found.

Phase 6: iPaaS Implementation via Zapier

In Zapier, implement this integration with the following Zap structure. Select GetResponse as the trigger app and choose the New Contact trigger event. Authenticate with your GetResponse API key and select the target list. In the Action step, select Salesforce and choose the Create or Update Lead action. Map the GetResponse output fields to Salesforce Lead fields: Contact Email → Email, Contact Name → split across First Name and Last Name using Zapier's Formatter > Text > Split step, Contact List Name → Lead Source Description, Contact ID → GetResponse Contact ID (Custom Field). Add a second Action step using Salesforce > Add Lead to Campaign to set Campaign Member status to Registered. For the unsubscribe flow, create a separate Zap with the GetResponse > Contact Unsubscribed trigger (available in Zapier's GetResponse integration) and a Salesforce > Update Lead action setting Email Opt Out to True.

Common Pitfalls & Troubleshooting

GetResponse Callback Not Firing for Tag Events The tag_applied callback action only fires when a tag is applied to a contact who is a member of a list specified in the callback's campaigns array. If a tag is applied to a contact who exists in your GetResponse account but is not subscribed to any of the listed campaigns, the callback will not fire. Additionally, GetResponse callbacks are registered at the API account level and are scoped to specific campaign IDs — you must register a callback for each list individually if you have contacts spread across multiple lists.

HTTP 429 Too Many Requests from GetResponse API GetResponse enforces rate limits of 400 requests per hour per API key for standard accounts and 5,000 requests per hour for MAX accounts. If your integration performs a full contact detail fetch for every callback event and you have a large, active list receiving many simultaneous subscribe events (e.g., during a webinar launch or campaign blast), you can hit this limit. Implement a queuing system that batches contact detail fetches and spaces them out over time. Additionally, consider using GetResponse's contact list export API for bulk synchronisation of historical contacts rather than relying solely on real-time callbacks, and use callbacks only for incremental updates.

Name Splitting Failures for Non-Standard Contact Names GetResponse stores contact names as a single name string. Splitting on the first space to extract FirstName and LastName breaks for contacts with single names (create FirstName: null, LastName: "Madonna"), names with prefixes ("Dr. Jane Doe" splits to FirstName: "Dr.", LastName: "Jane Doe"), and names with multiple spaces. Implement a robust name parser that handles these edge cases: detect single-word names and store them in LastName with FirstName set to a default placeholder (e.g., "Unknown"); strip common prefixes before splitting; take the last word as the last name and everything prior as the first name for multi-part names.

Salesforce Lead Conversion Conflicts When a Salesforce Lead is converted to a Contact and Account by a sales rep, subsequent API calls targeting the original Lead record will succeed (the Lead record still exists but is marked IsConverted: true) but will not update the associated Contact or Account records. If your integration updates the Lead's HasOptedOutOfEmail field after conversion, the corresponding Contact's opt-out status will not be updated, creating a compliance gap. Implement a conversion check: after any Lead upsert, query the Lead to check IsConverted. If true, retrieve the ConvertedContactId and apply the same update to the Contact record.

HTTP 400 — Required Field Missing on Salesforce Lead Creation Salesforce Lead creation requires LastName and Company fields at minimum. If your GetResponse contact record has no name (common for API-imported contacts or contacts where only an email was collected) or no company name, the Salesforce API call will fail with HTTP 400 and an REQUIRED_FIELD_MISSING error. Implement default fallback values in your field mapping: use "Unknown" for LastName if contact.name is null or empty, and use the email domain (extracted from the email address) as the Company value if no company is present (e.g., [email protected] → Company: "acmecorp.com"). This ensures no contact is dropped due to missing fields while making it easy to identify records that need enrichment in Salesforce.