Most small and mid-sized businesses in Vancouver run on a patchwork of software tools that don't talk to each other. Your CRM doesn't sync with your email marketing platform. Your payment processor doesn't automatically update your accounting software. Your booking system lives in a separate universe from your customer support tool.
The standard solution is Zapier or Make, which work fine for simple triggers. But when you need conditional logic, data transformation, or custom error handling, you hit a wall fast. The alternative is hiring a developer to build a custom integration — which usually means $3,000–6,000 and a two-week timeline.
Over the past year I've been building custom API integrations with Claude Code instead. The cost drops by 60–70%, the timeline shrinks to days instead of weeks, and I can iterate on the logic without waiting on a dev team's sprint schedule. Here's how I do it and when it makes sense.
What Counts as an API Integration
Before I get into specifics, it helps to define what I mean by "API integration." I'm talking about scripts that connect two or more software systems by sending and receiving data through their APIs — application programming interfaces.
Common examples from my client work:
- Pushing new leads from a contact form into a CRM and tagging them based on which service they inquired about
- Pulling order data from Shopify and creating invoices in QuickBooks
- Syncing customer data between a booking platform and an email marketing tool, with custom fields mapped between the two
- Fetching analytics data from Google Analytics and posting weekly summary reports into a Slack channel
These are the kinds of workflows that used to require either a full-time developer or an expensive Zapier subscription with premium features. Now they're something I can prototype in an afternoon.
How Claude Code Builds API Integrations
The process starts with API documentation. Every decent SaaS tool has a developer docs page that explains how to authenticate, what endpoints are available, and what data format each endpoint expects. I feed that documentation into Claude Code along with a plain-English description of what I want to happen.
For example, I recently built an integration for a client who runs a tutoring service. They wanted new student sign-ups from their booking form to automatically create a contact in their CRM, send a welcome email through their email platform, and post a notification to a private Slack channel for their admin team.
The prompt I gave Claude Code looked like this:
Build a Node.js script that runs when a webhook fires from the booking form. Extract the student's name, email, phone, and selected subject. Create a contact in Pipedrive CRM using their API. Send a welcome email via SendGrid with the template ID abc123. Post a message to Slack channel #new-students with the student's name and subject. Handle authentication for all three services and log any errors.
Claude Code wrote the script in about four minutes. It included error handling, retry logic for failed API calls, and environment variables for storing API keys securely. I tested it with sample data, caught one issue with date formatting, fed the error back, and had a working integration 30 minutes later.
Authentication and Security
One concern I hear often: is it safe to let AI handle API keys and authentication? The short answer is yes, if you follow basic security practices.
Claude Code doesn't store your API keys. It writes code that reads keys from environment variables or a secure config file. You're responsible for keeping those keys safe — the same way you would if a human developer built the integration.
For OAuth flows (where a user has to log in and authorize access), Claude Code can write the authorization URL and token exchange logic. You still need to go through the OAuth dance yourself the first time to get the access token. After that, the script handles token refresh automatically.
The one thing Claude Code can't do is debug network-level security issues — like IP whitelisting or certificate errors. If the API you're integrating with has unusual security requirements, you'll need a human to troubleshoot that. But for 90% of standard REST APIs, it handles authentication cleanly.
Data Transformation and Business Logic
The real value of custom integrations isn't just moving data from point A to point B. It's transforming the data along the way to match your business rules.
A client I work with sells both products and services. Their Shopify store handles product sales, but service bookings go through a separate scheduling platform. They wanted all revenue in one place — their accounting software — but the two systems format transaction data differently.
The integration I built with Claude Code does this:
- Fetches new orders from Shopify every hour
- Fetches new bookings from the scheduling platform
- Transforms both into a standardized invoice format
- Checks for duplicates (in case an order was already synced)
- Creates invoices in QuickBooks with the correct tax codes and account categories
The business logic — like which tax rate applies to which product category, or how to calculate booking fees — is encoded in the script. When their rules change, I update the script. No need to involve a developer or reconfigure Zapier workflows.
When to Use Claude Code vs. Zapier
I still recommend Zapier for simple one-step automations. If you just need new Typeform submissions to create a row in Google Sheets, use Zapier. It's faster and doesn't require any code.
Claude Code makes sense when:
- You need conditional logic that branches based on multiple criteria
- The data requires transformation that's too complex for Zapier's built-in formatter
- You're hitting Zapier's task limits and the cost is creeping up
- The integration involves more than 3–4 steps and you want better error visibility
- You need the integration to run on your own server or infrastructure
I wrote a longer comparison in my post on Claude Code vs. Zapier if you want more detail on when each tool is the right fit.
Real Client Example: CRM to Email Marketing Sync
A Vancouver real estate agent I work with was manually exporting contacts from their CRM every week and uploading them to Mailchimp. It took about 45 minutes per week and was error-prone — sometimes contacts got skipped, sometimes they got duplicate entries.
I built a bidirectional sync with Claude Code. New contacts added to the CRM automatically get pushed to Mailchimp with the correct tags based on their property interest (residential, commercial, investment). Email engagement data from Mailchimp — opens, clicks, unsubscribes — flows back into the CRM as activity notes.
The integration runs every six hours. When there's a conflict (e.g., the same contact was updated in both systems since the last sync), the script logs the conflict and sends a summary email so my client can resolve it manually. That happens maybe once a month.
Time saved: 45 minutes per week, or about 35 hours per year. The integration took me six hours to build and test. Payback period was under two months.
How Long Integrations Take to Build
Timeline depends on complexity and API quality. Here's what I've seen across 20+ client projects:
- Simple one-way sync (e.g., form submissions to CRM): 2–4 hours
- Two-way sync with conflict handling: 1–2 days
- Multi-step workflow with conditional logic: 2–3 days
- Integration with a poorly documented API: add 50% to any of the above
The biggest variable is API documentation. If the API docs are clear and include working examples, Claude Code can usually build a working integration on the first try. If the docs are incomplete or the API has undocumented quirks, expect more back-and-forth testing.
Maintenance and Updates
APIs change. A vendor releases a new version, deprecates an old endpoint, or changes the authentication method. When that happens, integrations break.
The advantage of having the integration in code (vs. a no-code tool) is that you can version-control it and update specific parts without rebuilding the whole thing. When one of my client's integrations breaks, I pull up the script, feed the new API docs into Claude Code, and ask it to update the relevant section. Usually takes 15–30 minutes.
I also set up monitoring for every integration I build. If an API call fails three times in a row, I get an alert. That way I can fix issues before my client even notices something's wrong.
What Claude Code Can't Do
I want to be clear about the limits. Claude Code is not a replacement for a senior software engineer when you're building complex distributed systems or dealing with high-volume data pipelines.
It also struggles with:
- APIs that require browser automation or JavaScript rendering to work
- Debugging network issues like firewall rules or DNS misconfigurations
- Optimizing performance for integrations that process thousands of records per minute
- Building admin UIs or dashboards on top of the integration
For standard REST API integrations that move data between business tools, it's more than capable. For anything that requires deep infrastructure knowledge or significant performance tuning, you still need a developer.
Getting Started
If you're a consultant or agency owner who wants to offer custom integrations without hiring a dev team, here's where to start:
- Pick one recurring manual task in your business that involves copying data between tools
- Check if both tools have public APIs (look for a "Developers" or "API" link in their footer)
- Write out the exact logic you want: "When X happens, do Y, then Z"
- Feed that logic + the API docs into Claude Code and ask it to build the integration
Start with something low-stakes. If it breaks, you can fall back to the manual process. Once you've built one working integration, the pattern becomes clear and you can apply it to more complex workflows.
I've documented my approach to automation in more detail in posts like Claude Code CRM Integration and Claude Code Workflow Automation for Consultants. And if you want help scoping an integration for your specific situation, reach out — I'm happy to walk through it.
The barrier to custom software isn't technical skill anymore. It's knowing what to ask for and how to test it. Once you figure that out, you can build integrations faster than you ever thought possible.