Integrating Salesforce and Stripe: Create a Unified Customer Search with Searches.do

In today's data-driven world, a complete understanding of your customer is paramount. Yet, this "360-degree view" often feels more like a myth than a reality. Your customer's journey is fragmented across multiple platforms: their sales history lives in Salesforce, while their billing and subscription data resides in Stripe.

For your support, sales, and engineering teams, this data silo creates constant friction. A support agent handling a billing query has to jump between browser tabs. A sales rep can't see a customer's subscription status before an upsell call. Your engineers are tasked with building and maintaining brittle, complex integration logic within your application code every time a new data point is needed.

What if you could solve this problem once and for all? What if you could merge these disparate data sources into a single, intelligent, and secure API endpoint? With Searches.do, you can. This is how you turn data chaos into "Search as Software."

The Challenge: Fragmented Customer Data

The problem is simple to state but difficult to solve with traditional methods. Critical customer information is split:

• In Salesforce: You have lead sources, contact details, communication logs, account ownership, and opportunity stages. It's the source of truth for your customer relationship.
• In Stripe: You have subscription plans, payment history, invoice statuses, and saved payment methods. It's the source of truth for your revenue.

To get a complete picture—for instance, finding a customer's subscription status and their associated sales account—an application typically has to:

1. Make an API call to Salesforce to find the contact by email.
2. Make a separate API call to Stripe to find the customer by that same email.
3. Receive two differently structured data objects.
4. Write custom code to parse, validate, and merge the information.
5. Handle errors and edge cases for both services independently.

This logic gets copied, pasted, and slightly modified across multiple microservices and applications, leading to a maintenance nightmare. A change in the Stripe API could break multiple internal tools.

The Solution: A Unified Search Agent with Searches.do

Searches.do provides an elegant solution by abstracting this complexity into a reusable, agentic workflow. We can build a single, intelligent search agent—let's call it get-customer-360—that handles the entire data retrieval and fusion process.

This agent becomes a new, powerful piece of your infrastructure, delivered as a simple API. Your application code no longer needs to know about Salesforce or Stripe. It only needs to ask one question to one service: "Get me the complete profile for this customer."

The get-customer-360 agent encapsulates the logic to:

1. Accept a single identifier, like an email address.
2. Securely query the Salesforce API for the contact record.
3. Concurrently query the Stripe API for the customer and subscription data.
4. Merge the results into a single, clean, and predictable JSON object.
5. Return that unified object to your application.

Building the get-customer-360 Agent: A Step-by-Step Guide

Creating an agent in Searches.do is a process of defining your business logic as code. You define the steps, connect the data sources, and shape the final output.

Step 1: Define the Search Goal

First, we define what the agent does.

• Input: An email string.
• Output: A unified JSON object containing key details from both systems.

Step 2: Write the Agent Logic (Business-as-Code)

Inside the Searches.do platform, you define your search as a series of steps. Your agent's definition might look conceptually like this:

# Agent Definition: get-customer-360
#
# This agent retrieves customer data from Salesforce and Stripe
# and merges it into a single profile.

agent: get-customer-360
input:
  email:
    type: string
    description: "The customer's email address."

# Define the sequence of operations for this agentic workflow.
steps:
  - name: find_salesforce_contact
    description: "Fetches contact and account info from Salesforce."
    source: salesforce_api # A pre-configured secure data source in Searches.do
    query: "SELECT Name, Email, Account.Name FROM Contact WHERE Email = '{{input.email}}' LIMIT 1"

  - name: find_stripe_customer
    description: "Fetches billing and subscription info from Stripe."
    source: stripe_api # A pre-configured secure data source
    query:
      method: customers.list
      params:
        email: "{{input.email}}"
        limit: 1

  - name: merge_and_format_data
    description: "Combines the results into a single, clean object."
    logic: |
      // Use JavaScript to transform and merge data from previous steps.
      const salesforce = steps.find_salesforce_contact.result[0];
      const stripe = steps.find_stripe_customer.result.data[0];

      if (!salesforce && !stripe) {
        throw new Error('Customer not found');
      }

      return {
        name: salesforce?.Name || stripe?.name,
        email: salesforce?.Email || stripe?.email,
        accountName: salesforce?.Account?.Name || 'N/A',
        stripeId: stripe?.id,
        subscriptionStatus: stripe?.subscriptions?.data[0]?.status || 'inactive',
        created: stripe?.created
      };

This definition is now a standalone, executable workflow. It's version-controlled, testable, and completely independent of any application.

Consuming Your New Unified API

The true power of this approach is the simplicity of consuming it. The complex, multi-step process is now hidden behind a single, powerful API call.

Here’s how your application code would use the newly created agent with the Searches.do client:

import { createClient } from 'searches.do';

// Initialize the client with your API key
const searches = createClient(process.env.DO_API_KEY);

// Effortlessly get a 360-degree customer view from a single call
async function getUnifiedCustomer(email: string) {
  try {
    const customerData = await searches.run('get-customer-360', {
      email: email
    });

    console.log('Unified Customer Profile:', customerData);
    // Now you have a single object with data from both Salesforce and Stripe!
    // e.g., customerData.subscriptionStatus and customerData.accountName
    return customerData;

  } catch (error) {
    console.error('Failed to retrieve unified customer data:', error);
  }
}

getUnifiedCustomer('jane.doe@example.com');

That’s it. Your application code is now clean, simple, and decoupled from the underlying data sources.

The Benefits of Integrating via Searches.do

By building this integration as a search agent, you unlock several key advantages:

• Simplicity & Maintainability: The complex data-stitching logic lives in one central, version-controlled location. If the Stripe API changes, you update one agent, not five different applications.
• Enhanced Security: Your applications no longer need to store credentials for Salesforce or Stripe. They only need a Searches.do API key. The agent acts as a secure proxy, preventing direct database access and exposing only the data you explicitly define in the merge_and_format_data step.
• Reusability: The get-customer-360 agent can be used by your customer support portal, your main web app, an internal admin dashboard, and your marketing analytics pipeline, ensuring a consistent and accurate view of the customer everywhere.
• Scalability & Performance: The Searches.do platform is built to handle, cache, and scale these workflows, ensuring your search API is always fast and reliable without you managing the infrastructure.

Stop wrestling with data silos and brittle integration code. Start thinking of data retrieval as intelligent software. By transforming your complex queries into simple, powerful services, you free your developers to focus on building features, not plumbing data.

Ready to create your first intelligent search agent? Discover how Searches.do can unify your data landscape today.