Infusionsoft by Keap

Go to keys.developer.keap.com and sign in with your Keap account credentials. Click 'Create New App' (or 'Register an Application' depending on the portal version). Give your app a name such as 'Bubble CRM Integration.' In the app settings, find the Redirect URI field. Enter your Bubble app's OAuth callback URL — the page you will create in the next step to receive the authorization code. The format is: `https://yourappname.bubbleapps.io/oauth_callback` (or your custom domain if you have one). If using a custom domain, make sure HTTPS is configured. After saving, the portal shows your **Client ID** and **Client Secret**. Copy both now — the Client Secret is only shown once in some portal versions. Store them securely outside of Bubble until you configure the API Connector. Note: Keap REST API v2 requires a Pro or Max subscription. If your account is on Lite, you will see authentication errors even with a valid OAuth app. Verify your Keap plan in Account Settings before proceeding. The Keap authorization URL you will use in the next step is: `https://accounts.infusionsoft.com/app/oauth/authorize` The token endpoint is: `https://api.infusionsoft.com/token`

1// Keap OAuth 2.0 endpoints:
2// Authorization URL: https://accounts.infusionsoft.com/app/oauth/authorize
3// Token URL: https://api.infusionsoft.com/token
4// Scopes: full
5
6// Authorization request (browser redirect):
7// GET https://accounts.infusionsoft.com/app/oauth/authorize
8//   ?client_id=YOUR_CLIENT_ID
9//   &redirect_uri=https://yourapp.bubbleapps.io/oauth_callback
10//   &response_type=code
11//   &scope=full

In your Bubble editor, click Plugins in the left sidebar and locate the API Connector plugin (install it from 'Add plugins' if it is not already present). Click 'Add another API' and name it 'Keap CRM.' In the API group settings, click 'Use as' and select 'Action.' Set the Authentication type to 'OAuth2 User-Agent.' Fill in the following fields: - **App name**: Keap CRM - **Authorization URL**: `https://accounts.infusionsoft.com/app/oauth/authorize` - **Access token URL**: `https://api.infusionsoft.com/token` - **Client ID**: paste your Keap Developer app Client ID - **Client Secret**: paste your Client Secret — ensure 'Private' is checked (this field is Private by default in OAuth2 setup) - **Scope**: `full` - **Redirect URL**: `https://yourappname.bubbleapps.io/oauth_callback` Bubble's OAuth2 User-Agent type will handle the browser redirect flow and token exchange automatically. However, because refresh tokens also need to be stored persistently for background API calls, you will supplement Bubble's built-in OAuth with a Backend Workflow (next step). Next, add a shared header at the API group level: `Authorization` with value `Bearer <access_token>` — mark the value as a dynamic parameter named `access_token` and check 'Private.' This shared header will appear on all calls within this API group. Add your first call: click 'Add another call,' name it 'Get Contacts,' set method to GET, URL to `https://api.infusionsoft.com/crm/rest/v2/contacts`. Add URL parameters: `given_name` (text, optional), `email_address` (text, optional), `limit` (number, default 25). Click 'Initialize call.' You must supply a valid access_token in the Private parameter field during initialization — use a token from the Keap API sandbox or run the authorization flow first. The response should return `{ "contacts": [...] }` — Bubble will detect the contacts array for list binding.

1// API Connector: Keap CRM → Get Contacts
2// Method: GET
3// URL: https://api.infusionsoft.com/crm/rest/v2/contacts
4//
5// Headers (shared at API group level):
6// Authorization: Bearer <access_token>  // mark Private
7//
8// URL Parameters:
9// given_name: <dynamic_first_name>      // optional
10// email_address: <dynamic_email>        // optional
11// limit: 25                             // max results per request
12// offset: 0                             // for pagination
13//
14// Example response structure:
15// {
16//   "contacts": [
17//     {
18//       "id": 123,
19//       "given_name": "Jane",
20//       "family_name": "Smith",
21//       "email_addresses": [{"email": "jane@example.com", "field": "EMAIL1"}],
22//       "tag_ids": [10, 20, 30]
23//     }
24//   ]
25// }

After the Keap authorization redirect, Bubble receives an authorization code as a URL parameter on your OAuth callback page. You need a Backend Workflow that exchanges this code for an access_token and refresh_token, then stores both in the current User's data record. First, create a custom data type field on the User object: go to Data tab → User type → add a field `keap_access_token` (text), `keap_refresh_token` (text), and `keap_token_expiry` (date). Next, go to Settings → API → check 'This app exposes a Workflow API.' Then open the Backend Workflows section and click 'Add workflow.' Name it `keap_token_exchange`. In this Backend Workflow, add a 'Detect data' step to capture two incoming parameters: `code` (text) and `user_id` (text) — you will pass the current user's Bubble ID when calling this workflow. Add an API Connector action: call the Keap token endpoint. Create a separate API Connector call named 'Exchange Token' with method POST, URL `https://api.infusionsoft.com/token`, Content-Type `application/x-www-form-urlencoded`, and body parameters: - `grant_type` = `authorization_code` - `client_id` = your Client ID (static, not private since it is not a secret) - `client_secret` = your Client Secret (mark Private) - `code` = `<dynamic_code>` (from incoming parameter) - `redirect_uri` = your callback URL After the token exchange call returns, add 'Make changes to a Thing' to update the User record (found by `user_id`) with the returned `access_token`, `refresh_token`, and the expiry time (Current date/time + 86400 seconds ≈ 24 hours, though Keap tokens may vary). On your OAuth callback page, add a page-load workflow: when the page loads and URL parameter `code` is not empty, call 'Schedule API Workflow' to trigger `keap_token_exchange` at Current date/time, passing `code` = Page URL parameter `code` and `user_id` = Current User's unique ID.

1// API Connector: Keap → Exchange Token
2// Method: POST
3// URL: https://api.infusionsoft.com/token
4// Content-Type: application/x-www-form-urlencoded
5//
6// Body parameters (form-encoded):
7// grant_type=authorization_code
8// client_id=YOUR_CLIENT_ID
9// client_secret=YOUR_CLIENT_SECRET    // mark Private
10// code=<dynamic_authorization_code>   // from URL parameter
11// redirect_uri=https://yourapp.bubbleapps.io/oauth_callback
12//
13// Successful response:
14// {
15//   "access_token": "eyJ...",
16//   "token_type": "bearer",
17//   "expires_in": 86400,
18//   "refresh_token": "rtoken...",
19//   "scope": "full"
20// }
21
22// Token refresh call (same endpoint, different grant_type):
23// grant_type=refresh_token
24// refresh_token=<stored_refresh_token>
25// client_id=YOUR_CLIENT_ID
26// client_secret=YOUR_CLIENT_SECRET

With OAuth tokens stored, you can now build the core CRM actions. The two most important write operations are creating a contact and applying tags. **Creating a contact:** Add a new API Connector call under Keap CRM, name it 'Create Contact,' method POST, URL `https://api.infusionsoft.com/crm/rest/v2/contacts`. The JSON body should include the basic contact fields: ``` { "given_name": "<dynamic_first_name>", "family_name": "<dynamic_last_name>", "email_addresses": [ { "email": "<dynamic_email>", "field": "EMAIL1" } ], "phone_numbers": [ { "number": "<dynamic_phone>", "field": "PHONE1" } ] } ``` The response includes the new contact's `id` — store this in a Custom State or Bubble database field if you need to immediately apply tags. **Applying tags:** Add another call named 'Apply Tags,' method POST, URL `https://api.infusionsoft.com/crm/rest/v2/contacts/<contact_id>/tags`. The body must be a JSON array: `{ "tagIds": [<tag_id_1>, <tag_id_2>] }`. The `tagIds` value must be a JSON array of integers — not a comma-separated string and not a single integer. To get available tag IDs, add a 'Get Tags' call: GET `https://api.infusionsoft.com/crm/rest/v2/tags` — this returns all tags with their `id` and `name`. You can populate a Bubble dropdown with this list and let users select tags by name, then pass the numeric IDs in the apply-tags action. In your Bubble workflow, the sequence is: (1) call Create Contact, (2) extract the returned `id` from the response and store in a state, (3) call Apply Tags passing the stored ID and selected tag IDs. All three steps run server-side inside a Backend Workflow for security.

1// API Connector: Keap CRM → Create Contact
2// Method: POST
3// URL: https://api.infusionsoft.com/crm/rest/v2/contacts
4// Authorization: Bearer <access_token>  // Private
5// Content-Type: application/json
6//
7// Body:
8{
9  "given_name": "<dynamic_first_name>",
10  "family_name": "<dynamic_last_name>",
11  "email_addresses": [
12    { "email": "<dynamic_email>", "field": "EMAIL1" }
13  ],
14  "phone_numbers": [
15    { "number": "<dynamic_phone>", "field": "PHONE1" }
16  ]
17}
18
19// API Connector: Keap CRM → Apply Tags
20// Method: POST
21// URL: https://api.infusionsoft.com/crm/rest/v2/contacts/<contact_id>/tags
22// Authorization: Bearer <access_token>  // Private
23// Content-Type: application/json
24//
25// Body (MUST be a JSON array of integers, not a string):
26{
27  "tagIds": [42, 107, 215]
28}

Now surface Keap contact data in your Bubble app's UI. The primary pattern is a search page with a Text Input for name/email and a Repeating Group displaying results. On your CRM page, add a Text Input element for search. Add a Button labeled 'Search' and a Repeating Group below it. Set the Repeating Group's data type to 'External API' and its data source to the result of the 'Get Contacts' API Connector call. Wire the search button's click workflow to 'Reset relevant inputs' and then set the Repeating Group's data source dynamically. In the API Connector Get Contacts call, pass the Text Input's value as the `given_name` or `email_address` parameter. Because Keap searches these fields separately, consider building two calls (one for name, one for email) or using the `email_address` parameter when the input looks like an email (contains '@'). Inside each row of the Repeating Group, display: - Contact name: `Current cell's contacts's given_name` + `family_name` - Email: `Current cell's contacts's email_addresses's first item's email` - Tags: a nested Repeating Group or comma-joined list of tag names For tag display, you need to join the numeric `tag_ids` from the contact response with the tag names from your 'Get Tags' call. Cache the tag list in a Custom State on page load to avoid repeated API calls per row — calling Get Tags inside the Repeating Group row would fire once per visible contact, rapidly consuming API rate limits. Add a 'Load more' button that increments the `offset` parameter by 25 on each click to implement pagination.

1// Page workflow: Search button clicked
2// Action 1: Reset group - Repeating Group Contacts
3// Action 2: Refresh API Connector result
4//   Call: Keap CRM - Get Contacts
5//   given_name: Search Input's value  (if not email-format)
6//   email_address: Search Input's value  (if contains @)
7//   limit: 25
8//   offset: 0
9
10// Repeating Group data source:
11// Type of content: Keap CRM - Get Contacts - contacts
12// Data source: Get data from external API → Keap CRM - Get Contacts
13
14// For tag display inside each row:
15// Do NOT call Get Tags per row — load once on page load:
16// Page load workflow → Get Tags → store result in Custom State 'All Tags'
17// In row: filter All Tags list where tag id is in Current cell's tag_ids

Keap access tokens expire — build a proactive refresh mechanism so your app never fails mid-session with a 401 error. **Token refresh Backend Workflow:** Create a workflow named `keap_refresh_token`. It calls the Keap token endpoint with `grant_type=refresh_token` and the current User's stored refresh_token. On success, it updates the User's `keap_access_token` and `keap_token_expiry`. **Pre-call check:** Before every Keap API call, add a condition check in your workflow: if `Current User's keap_token_expiry` is less than 5 minutes from now, run the `keap_refresh_token` Backend Workflow first, then proceed with the API call. In Bubble workflow terms: add a 'Schedule API Workflow' action for the refresh, followed by a 'Pause before next action' set to 2 seconds, then the actual Keap call. This is not perfectly atomic but works for most use cases. **Testing the end-to-end flow:** 1. In your Bubble preview, navigate to a page with a 'Connect Keap' button 2. The button triggers the OAuth authorization URL as an external link (Target = '_blank') 3. Log in to Keap and authorize the app 4. Keap redirects back to your OAuth callback page with a `?code=` parameter 5. The page-load workflow fires `keap_token_exchange` 6. Verify tokens are stored: Data tab → User → check your test user's keap_access_token field 7. Navigate to the CRM search page and run a contact search 8. Check Bubble Logs tab → Workflow logs to confirm the API call returned 200 For debugging, use the Logs tab → Workflow logs to inspect each step. If a call returns 401, check that the access_token in the User record is not expired and that the Authorization header is reading from the correct field. RapidDev's team has built OAuth-connected Bubble apps with integrations like this across dozens of client projects — if you get stuck on the token flow, reach out for a free scoping call at rapidevelopers.com/contact.

1// Token refresh API call:
2// Method: POST
3// URL: https://api.infusionsoft.com/token
4// Content-Type: application/x-www-form-urlencoded
5//
6// Body:
7// grant_type=refresh_token
8// refresh_token=<Current User's keap_refresh_token>  // Private
9// client_id=YOUR_CLIENT_ID
10// client_secret=YOUR_CLIENT_SECRET  // Private
11//
12// Bubble workflow sequence for pre-call token check:
13// Condition: Current User's keap_token_expiry < Current date/time + 5 minutes
14//   YES → Schedule API Workflow: keap_refresh_token (at Current date/time)
15//         Pause before next action: 2 seconds
16//         [Then proceed with Keap API call]
17//   NO  → [Proceed directly with Keap API call]