Integrating Whippy API with Your CRM for SMS Automation

1. Introduction

Your CRM — whether it’s Salesforce, HubSpot, Bullhorn, or Crelate — holds the lifeblood of your business: contacts, leads, deals, and activity history. Yet, most CRMs are data-rich but communication-poor — precisely where CRM communication automation with Whippy adds value.

When you need to confirm interviews, follow up on demos, or trigger ticket alerts, you often have to rely on separate tools. That creates silos, delays, and missed opportunities.

The solution is to integrate your CRM with Whippy API. This guide shows you how to connect your CRM to Whippy’s communication platform — with step-by-step instructions, cURL requests, Python and Node.js examples, and best practices that help both developers and decision-makers.

2. Why Integrate Whippy with a CRM?

The use cases for Whippy CRM integration span industries and bring measurable business impact. By embedding business texting directly into your CRM workflows, teams achieve faster outreach, better tracking, and higher engagement compared to traditional communication channels and standalone SMS tools.

SMS vs Email: Engagement Statistics

Across industries, SMS consistently outperforms email as a communication channel:

• Open rates for SMS are widely acknowledged to be far higher, often reaching the vast majority of recipients, while email averages remain much lower.
• Response times are dramatically faster with SMS — typically within minutes — compared to the hours or even days it can take for an email to be read and answered.
• Response rates from SMS campaigns are regularly reported in the double digits, whereas email campaigns tend to produce single-digit results.

By integrating Whippy’s API into your CRM, you’re not just sending messages — you’re enabling automated SMS from CRM and tapping into a channel that naturally delivers faster engagement and higher response rates.

Comparison: CRM Without vs With Whippy Integration

Impact Across Business Functions

• Recruitment SMS automation: With Bullhorn or Crelate, recruiters can auto-send interview reminders, reschedule notices, and “thank you” follow-ups. This often leads to a noticeable reduction in candidate no-shows and faster placement speed.
• Sales CRM messaging integration: In Salesforce or HubSpot, sales reps can trigger personalized SMS campaigns via the HubSpot SMS API, and teams leveraging Salesforce SMS integration see higher meeting confirmations and shorter sales cycles.
• Customer support SMS alerts: With Zendesk or Freshdesk, instant SMS notifications reassure customers, while replies sync back into tickets. This reduces inbound “status check” calls and improves customer satisfaction.
• Marketing CRM automation API: Marketers can launch segmented campaigns with Whippy, track engagement, and feed metrics back into CRM dashboards. Businesses leveraging SMS frequently see click-through rates many times higher than typical email results.

The result: faster communication, higher deliverability, improved engagement, and a CRM that evolves from being just a database of contact information into a seamlessly integrated communication hub.

3. Getting Started with Whippy API

Authentication with Whippy API Key

To interact with Whippy, every request must be authenticated using your API key. This key is passed in the request header X-Whippy-Key. Without it, no call will succeed.

cURL Example (List contacts via API):

1curl --request GET \\
2  --url <https://api.whippy.ai/v1/contacts> \\
3  --header 'X-Whippy-Key: YOUR_API_KEY'

Python Example:

1import requests
2
3headers = {"X-Whippy-Key": "YOUR_API_KEY"}
4
5response = requests.get("<https://api.whippy.ai/v1/contacts>", headers=headers)
6print(response.json())

Node.js Example:

1const axios = require("axios");
2
3axios.get("<https://api.whippy.ai/v1/contacts>", {
4  headers: { "X-Whippy-Key": "YOUR_API_KEY" }
5}).then(res => console.log(res.data));

How to Generate an API Key (Step by Step)

1. Log in to your Whippy dashboard.

2. Go to Settings > API Keys.

3. Click Generate API Key.

4. Copy the key and store it securely (e.g., environment variables, a secret manager).

5. Never paste the key directly into public repositories or client-side apps on mobile devices.

Common Mistakes to Avoid

• Forgetting HTTPS: All Whippy calls require https://.
• Invalid Headers: Must be X-Whippy-Key — case-sensitive.
• Expired Keys: If you rotate or revoke a key in the dashboard, update all environments.
• Exposing Keys: Never hardcode API keys in GitHub repos or apps — this is especially risky if your team builds CRM add-ons for mobile devices.

Following these steps ensures your integration remains secure and reliable.

Receiving SMS via Webhooks (Part of Setup)

Whippy supports not just sending, but also receiving SMS replies through webhook CRM integration, enabling reliable two-way flows. This makes it possible to build two-way communication flows and automate contact management inside your CRM.

Steps to enable SMS receiving via webhooks:

1. Create an endpoint in your CRM or middleware (e.g., /webhooks/whippy).

2. Register that URL under Webhooks in the Whippy dashboard.

3. Whippy will send POST requests whenever a reply is received.

Webhook Payload Example (receiving SMS):

1{
2  "event": "message.replied",
3  "data": {
4    "id": "msg_456",
5    "from": "+15551234567",
6    "to": "+15557654321",
7    "body": "Yes, I’m available for the meeting.",
8    "timestamp": "2025-01-01T00:00:00Z"
9  }
10}

With this setup, your CRM can automatically update the contact management record, mark an appointment as confirmed, or notify the assigned team member. This ensures the process is seamless whether the reply comes from a desktop or mobile device.

4. Step-by-Step CRM Integration

This section shows exactly how to wire your CRM to Whippy with working requests. It focuses on the how.

0) Environment Setup (recommended)

Create a .env file and load it in your app so keys never live in code.

.env

1WHIPPY_API_KEY=your_whippy_api_key_here
2WHIPPY_API_BASE=https://api.whippy.ai/v1
3WHIPPY_FROM_NUMBER=+15557654321

Python (env loader)

1import os
2from dotenv import load_dotenv
3
4load_dotenv()
5
6API_KEY = os.getenv("WHIPPY_API_KEY")
7API_BASE = os.getenv("WHIPPY_API_BASE", "<https://api.whippy.ai/v1>")
8FROM_NUMBER = os.getenv("WHIPPY_FROM_NUMBER")
9
10HEADERS = {"X-Whippy-Key": API_KEY, "Content-Type": "application/json"}

Node.js (env loader)

1require("dotenv").config();
2
3const API_KEY = process.env.WHIPPY_API_KEY;
4const API_BASE = process.env.WHIPPY_API_BASE || "<https://api.whippy.ai/v1>";
5const FROM_NUMBER = process.env.WHIPPY_FROM_NUMBER;
6
7const HEADERS = { "X-Whippy-Key": API_KEY, "Content-Type": "application/json" };

Step 1: Send Text Messages from CRM

When a new lead enters your CRM, send SMS via API immediately.

cURL

1curl --request POST \\
2  --url <https://api.whippy.ai/v1/messages> \\
3  --header 'X-Whippy-Key: YOUR_API_KEY' \\
4  --header 'Content-Type: application/json' \\
5  --data '{
6    "to": "+15551234567",
7    "from": "+15557654321",
8    "body": "Hi {{first_name}}, thanks for signing up!"
9  }'

Python

1import requests, json
2
3payload = {
4  "to": "+15551234567",
5  "from": FROM_NUMBER,
6  "body": "Hi {{first_name}}, thanks for signing up!"
7}
8
9r = requests.post(f"{API_BASE}/messages", headers=HEADERS, data=json.dumps(payload))
10print(r.status_code, r.json())

Node.js

1const axios = require("axios");
2
3async function sendMessage(to, body) {
4  const payload = { to, from: FROM_NUMBER, body };
5  const res = await axios.post(`${API_BASE}/messages`, payload, { headers: HEADERS });
6  console.log(res.status, res.data);
7  return res.data;
8}
9
10sendMessage("+15551234567", "Hi {{first_name}}, thanks for signing up!");

Expected response (HTTP 201 Created):

1{
2  "id": "msg_123",
3  "to": "+15551234567",
4  "from": "+15557654321",
5  "status": "queued"
6}

Note: The status field may return as queued or sent, depending on timing.

Idempotency & retries (messages):

If you retry a POST /messages after a timeout or 429/500, you could accidentally send duplicates. Add a dedupe key in your app (e.g., store a “last sent hash” on the CRM activity, or wrap sending behind a job that marks completion atomically). Only perform exponential backoff retries on 429/500, and log message IDs returned.

Step 2: Automate Workflows with Webhooks (two-way SMS integration)

Whippy posts events (created, delivered, replied) to your webhook; implement robust webhook event handling in your CRM endpoint to update timelines, trigger follow-ups, or escalate support tickets.

Example webhook payload

1{
2  "event": "message.delivered",
3  "data": {
4    "id": "msg_123",
5    "to": "+15551234567",
6    "status": "delivered",
7    "timestamp": "2025-01-01T00:00:00Z"
8  }
9}

Minimal Express handler (Node.js)

1const express = require("express");
2const app = express();
3
4app.use(express.json());
5
6app.post("/webhooks/whippy", (req, res) => {
7  const { event, data } = req.body;
8
9  verifySignature(req.body, req.headers["X-Whippy-Signature"]);
10  // Update CRM record / ticket by data.id or phone
11
12  res.sendStatus(200); // Acknowledge quickly; do heavy work async
13});
14
15app.listen(3000, () => console.log("Webhook listening on :3000"));

Expected response to Whippy from your server

1HTTP/1.1 200 OK

Respond fast; do heavy processing asynchronously to avoid retries.

Step 3: Sync CRM Contacts with Whippy (idempotent upsert via external_id)

Keep contact information in sync using Whippy’s contact sync API (/contacts). Use your CRM’s Contact/Lead ID in external_id so repeated calls update the same person (safe to retry).

cURL

1curl --request POST \\
2  --url <https://api.whippy.ai/v1/contacts> \\
3  --header 'X-Whippy-Key: YOUR_API_KEY' \\
4  --header 'Content-Type: application/json' \\
5  --data '{
6    "external_id": "crm_456",
7    "first_name": "Jane",
8    "last_name": "Doe",
9    "phone": "+15553456789"
10  }'

Python

1import requests, json
2
3contact = {
4  "external_id": "crm_456",  # your CRM contact ID
5  "first_name": "Jane",
6  "last_name": "Doe",
7  "phone": "+15553456789"
8}
9
10r = requests.post(f"{API_BASE}/contacts", headers=HEADERS, data=json.dumps(contact))
11print(r.status_code, r.json())

Node.js

1const axios = require("axios");
2
3async function upsertContact(c) {
4  const res = await axios.post(`${API_BASE}/contacts`, c, { headers: HEADERS });
5  return res.data;
6}
7
8upsertContact({ external_id: "crm_456", first_name: "Jane", last_name: "Doe", phone: "+15553456789" })
9  .then(console.log);

Expected response (HTTP 200 OK; first insert may return HTTP 201 Created):

1{
2  "id": "cnt_789",
3  "external_id": "crm_456",
4  "phone": "+15553456789",
5  "updated": true
6  }

Note: First insert may return HTTP 201 Created; subsequent upserts typically return HTTP 200 OK.

Idempotency & retries (contacts):

Because you’re using external_id, retries are safe—the same record is updated, not duplicated. Prefer this pattern for any workflow that might retry on 429/500.

Example: Whippy syncing contacts with Crelate

The following screenshot shows how contacts from your CRM (in this case, Crelate) stay in sync with Whippy after using the contact sync API:

Whippy contact sync in action — Crelate contact records automatically updated via API

Step 4: Trigger Automated SMS Campaigns

Kick off a CRM-driven campaign by audience + template.

cURL

1curl --request POST \\
2  --url <https://api.whippy.ai/v1/campaigns> \\
3  --header 'X-Whippy-Key: YOUR_API_KEY' \\
4  --header 'Content-Type: application/json' \\
5  --data '{
6    "name": "Spring Promo",
7    "audience_id": "aud_789",
8    "template_id": "tmp_123"
9  }'

Python

1import requests, json
2
3campaign = { "name": "Spring Promo", "audience_id": "aud_789", "template_id": "tmp_123" }
4
5r = requests.post(f"{API_BASE}/campaigns", headers=HEADERS, data=json.dumps(campaign))
6print(r.status_code, r.json())

Node.js

1const axios = require("axios");
2
3async function startCampaign(name, audienceId, templateId) {
4  const payload = { name, audience_id: audienceId, template_id: templateId };
5  const res = await axios.post(`${API_BASE}/campaigns`, payload, { headers: HEADERS });
6  return res.data;
7}
8
9startCampaign("Spring Promo", "aud_789", "tmp_123").then(console.log);

Expected response (HTTP 201 Created):

1{
2  "id": "cmp_456",
3  "name": "Spring Promo",
4  "status": "queued"
5}

Note: Returns HTTP 201 Created on successful creation.

Idempotency & retries (campaigns):

If you must retry POST /campaigns, you risk launching twice. Mitigate by:

• Creating the campaign once and scheduling/running it with a separate idempotent action.
• Storing the returned cmp_* and checking existence before retrying.
• Using a job queue that marks campaign creation as complete atomically.

Tiny SDK-Style Helpers (for reuse)

Python helper

1import requests, os, json
2from dotenv import load_dotenv
3
4load_dotenv()
5
6API_BASE = os.getenv("WHIPPY_API_BASE", "<https://api.whippy.ai/v1>")
7HEADERS = {"X-Whippy-Key": os.getenv("WHIPPY_API_KEY"), "Content-Type": "application/json"}
8
9def whippy_post(path, payload):
10    r = requests.post(f"{API_BASE}{path}", headers=HEADERS, data=json.dumps(payload), timeout=15)
11    r.raise_for_status()
12    return r.json()
13
14def send_sms(to, body, from_number=os.getenv("WHIPPY_FROM_NUMBER")):
15    return whippy_post("/messages", {"to": to, "from": from_number, "body": body})
16
17def upsert_contact(external_id, **fields):
18    payload = {"external_id": external_id, **fields}
19    return whippy_post("/contacts", payload)

Node.js helper

1require("dotenv").config();
2const axios = require("axios");
3
4const API_BASE = process.env.WHIPPY_API_BASE || "<https://api.whippy.ai/v1>";
5const HEADERS = { "X-Whippy-Key": process.env.WHIPPY_API_KEY, "Content-Type": "application/json" };
6
7async function whippyPost(path, payload) {
8  const res = await axios.post(`${API_BASE}${path}`, payload, { headers: HEADERS, timeout: 15000 });
9  return res.data;
10}
11
12async function sendSms(to, body, fromNumber = process.env.WHIPPY_FROM_NUMBER) {
13  return whippyPost("/messages", { to, from: fromNumber, body });
14}
15
16async function upsertContact(externalId, fields = {}) {
17  return whippyPost("/contacts", { external_id: externalId, ...fields });
18}
19
20module.exports = { sendSms, upsertContact };
21

Retry note (safe patterns):

Safe to retry: reads (GET), contact upserts with external_id (POST /contacts).

Be careful retrying: message sends and campaign creation (POST /messages, POST /campaigns) — add dedupe checks in your app or queue.

5. Analytics & Tracking with Whippy API

Measuring performance is just as important as being able to send SMS messages from your CRM. Whippy’s SMS API for CRM doesn’t stop at delivery — it also provides rich analytics through the campaign analytics API, so every SMS campaign can be tied directly to outcomes in sales, recruitment, and support.

Example request (cURL)

1curl --request GET \\
2  --url <https://api.whippy.ai/v1/campaigns/cmp_123/stats> \\
3  --header 'X-Whippy-Key: YOUR_API_KEY'

Example response

1{
2  "delivered": 1842,
3  "clicked": 529,
4  "opt_outs": 37,
5  "conversion_rate": 28.7
6}

These metrics cover deliverability, open rates, click-through rates, opt-outs, and conversions — all tied back to the right customer information in your CRM.

Example Dashboard: CRM + Whippy Metrics

When Whippy analytics are combined with CRM data, you get a unified view of performance across your business:

For recruiters, this means Bullhorn SMS integration and Crelate SMS automation campaigns can be tracked in the same dashboards where candidate placements are reported. For sales teams, it means every lead touchpoint is visible end-to-end.

To illustrate, here’s how Crelate SMS integration with Whippy looks in action — preparing both a single message and a bulk SMS campaign:

Preparing a single SMS inside Crelate with Whippy integration

Preparing a bulk SMS campaign in Crelate with Whippy integration

How Analytics Improve Personalization & ROI

Analytics from Whippy don’t just measure; they guide improvements:

• Delivery + open rate data → show the best times to send SMS messages.
• Click-through data → reveals which personalized message templates resonate most.
• Opt-out patterns → highlight where messaging needs to be refined.

By feeding these insights back into your CRM, your team can refine automation workflows that improve long-term ROI. Every campaign gets smarter because it’s backed by data, not assumptions.

Using Response Rates to Guide Automation

One of the most powerful aspects of Whippy’s SMS API for CRM is the ability to act on response rates in real time:

• High response rates → CRM automatically routes engaged leads to a team member for fast follow-up.
• Low response rates → marketing can adjust segmentation or try new offers.

Every time you receive text messages (via webhook), your CRM updates the associated customer information: confirmed appointments, opt-ins, support resolution, etc.

This creates a closed loop where campaign data not only informs reports, but also powers smarter automation — from Bullhorn SMS integration reducing candidate no-shows to Crelate SMS automation nurturing talent pools more effectively.

6. Best Practices for API Integration

Rate Limits API & Exponential Backoff Retries

Whippy enforces rate limits to ensure fair usage and reliable performance across all customers. When building CRM SMS integration, your system must handle these limits gracefully and retry requests when necessary.

Common Error Codes

• 400 → Bad request (invalid payload)
• 401 → Unauthorized (invalid API key)
• 404 → Resource not found
• 429 → Too many requests (rate limit exceeded)
• 500 → Temporary server error

When you hit a 429 or 500, the correct approach is to retry the request using exponential backoff. This prevents your system from overwhelming the API while still ensuring delivery.

Python Example with Exponential Backoff Retries

1import time, requests
2
3headers = {"X-Whippy-Key": "YOUR_API_KEY"}
4retry_delay = 1
5
6while True:
7    res = requests.get("<https://api.whippy.ai/v1/contacts>", headers=headers)
8    if res.status_code == 200:
9        print("Success:", res.json())
10        break
11    elif res.status_code in (429, 500):
12        time.sleep(retry_delay)
13        retry_delay = min(retry_delay * 2, 60)  # Cap delay at 60s
14    else:
15        raise Exception(res.text)

Node.js Example

1const axios = require("axios");
2
3async function fetchContacts() {
4  let retryDelay = 1000; // 1 second
5
6  while (true) {
7    try {
8      const res = await axios.get("<https://api.whippy.ai/v1/contacts>", {
9        headers: { "X-Whippy-Key": "YOUR_API_KEY" }
10      });
11      console.log("Success:", res.data);
12      break;
13    } catch (err) {
14      if ([429, 500].includes(err.response?.status)) {
15        console.log(`Retrying in ${retryDelay / 1000}s...`);
16        await new Promise(r => setTimeout(r, retryDelay));
17        retryDelay = Math.min(retryDelay * 2, 60000); // cap at 60s
18      } else {
19        throw err;
20      }
21    }
22  }
23}
24
25fetchContacts();

Best practice: Always assume retries may be needed. This ensures SMS deliverability for campaigns at scale and prevents bottlenecks when multiple support tickets or workflows are triggered at the same time.

Handling Opt-Outs Compliantly

Modern omnichannel CRM integration requires compliance with carrier and legal requirements. With Whippy, you can manage opt-outs seamlessly:

1. Customers reply “STOP” to unsubscribe.

2. Whippy posts an opt_out event to your webhook.

3. Your CRM updates the contact record automatically.

This ensures you don’t send future two-way SMS integration messages to unsubscribed users, keeping your customer information accurate and compliant.

Webhook Security with X-Whippy-Signature

When Whippy calls your webhook, it includes an X-Whippy-Signature header. Always validate this to ensure the request is legitimate.

Python Example

1import hmac, hashlib
2
3def verify_signature(payload, header_signature, secret):
4    computed = hmac.new(
5        secret.encode(),
6        payload.encode(),
7        hashlib.sha256
8    ).hexdigest()
9    return hmac.compare_digest(computed, header_signature)

Always:

• Validate the signature.
• Accept only HTTPS requests.
• Log failed validations for security audits.

Beyond SMS: Calls and Omnichannel Security

Whippy isn’t just for SMS — its APIs also support phone call workflows and email notifications, all tied back into the CRM. Applying the same retry logic, opt-out handling, and webhook validation across every channel ensures your omnichannel CRM integration remains secure, scalable, and compliant.

7. Real-World Use Cases

This section is for business leaders and operations teams. Instead of code, it focuses on outcomes and workflows that Whippy enables.

Recruitment SMS Automation (Bullhorn & Crelate)

Recruiters who implemented Whippy’s CRM SMS integration often report fewer candidate no-shows, helping improve hiring efficiency.

Workflow

• Recruiter moves candidate to “Interview Scheduled.”
• Whippy sends a confirmation SMS.
• Candidate replies YES.
• CRM updates automatically through two-way SMS integration.

Business impact: Faster hiring cycles and fewer wasted interviews.

Sales CRM Messaging Integration (HubSpot & Salesforce)

Sales reps have seen stronger demo attendance rates by combining email with Whippy SMS, leading to more consistent engagement.

Workflow

• Lead books a demo → Whippy sends SMS confirmation.
• Customer clicks the link; CRM logs the activity.
• Managers see SMS deliverability metrics and CTR alongside pipeline data.

Business impact: Higher engagement and faster sales cycles.

Customer Support SMS Alerts (Zendesk & Freshdesk)

Support teams using Whippy often experience fewer inbound status-check calls, giving agents more time to focus on resolving issues.

Workflow

• Ticket moves to In Progress.
• Customer receives an instant SMS.
• Replies flow back into Zendesk automatically.

Business impact: Customers stay informed, agents save time, and support tickets close faster.

Marketing & Re-Engagement Campaigns

Reactivation campaigns powered by Whippy have shown measurable lifts in conversion compared to email-only outreach.

Workflow

• Marketers segment inactive customers in Salesforce.
• Campaign sent through Whippy with personalized offers.
• CRM dashboards track clicks, opt-outs, and revenue.

Business impact: Higher ROI on marketing and stronger customer retention.

Phone Call Workflow (VoIP)

Whippy adds more than SMS — it supports phone call workflows.

Workflow

• A lead replies CALL ME.
• Whippy auto-dials and connects them to the next available team member.
• CRM logs both SMS and call outcomes, creating a true omnichannel CRM integration.

Business impact: Customers choose their preferred channel (text or call), improving response rates and deal velocity.

Collaboration & Shared Inbox

Every team member can see the full thread (SMS, email, phone logs) in Whippy’s shared inbox.

Workflow

• Conversations are tied to CRM customer information, ensuring context for every interaction.
• Using the error handling API, teams troubleshoot failed deliveries together.

Business impact: Accountability, compliance, and full visibility across all communication channels.

8. Conclusion & Next Steps

When you integrate CRM with SMS API technology like Whippy’s, you transform your CRM from a static database into a centralized communication hub. Instead of being limited to managing records, your CRM becomes the orchestrator of real-time, omnichannel engagement.

Your business isn’t just sending texts — you’re building connected customer journeys that flow across:

1. 

   SMS for instant, high-engagement messaging.

2. 

   Email for longer-form communication and nurturing.

3. 

   Phone calls for direct conversations when urgency/complexity requires it.

4. 

   Mobile app notifications for real-time updates on the go.

With all of these channels seamlessly integrated into your CRM, teams gain:

1. 

   Smarter automation workflows: trigger the right channel at the right time, automatically.

2. 

   Higher data accuracy: every opt-in, reply, and call outcome linked to the right record.

3. 

   Better team collaboration: one shared inbox where every team member can see the full conversation history.

4. 

   Improved ROI and customer satisfaction: higher response rates, fewer missed opportunities, and stronger relationships.

If your business is ready to move beyond manual outreach into scalable, omnichannel automation, now is the time to explore the Whippy API.

Request a demo of Whippy CRM integration today and discover how to transform your CRM into a true communication platform ⪢

Or check out the Whippy Products page to explore features like Campaigns, Inbox, Automations, and more ⪢