How do I connect my website to a CRM, payment processor or booking tool?

This page may contain affiliate links from which Blur Studio earns commissions.

A static website, the kind most small businesses run, doesn't have a server sitting behind it that can securely call another API, store a secret key, or run custom logic. That's normally fine, until you need your site to actually do something: charge a card, check real-time availability, or push a form submission into a CRM with fields mapped and validated first. That's the gap serverless functions fill.

Check the simple option first

Before building anything, see whether a no-code connector already does the job. Zapier and Make both have pre-built connections to most popular CRMs, payment tools and booking systems, and if your need is "when a form submits, create a record over there," that's exactly what they're built for, with no code and no function to maintain. This genuinely covers a large share of what people think they need custom code for.

Where it stops being enough is when you need actual logic in between: checking a price against your own rules before sending it to a payment processor, validating that a booking slot is real before confirming it, or combining data from two sources before passing it along. A chain of no-code steps can sometimes fake this, but it gets fragile and hard to debug fast. That's the point where a small serverless function is the cleaner tool.

How Netlify Functions actually work

A function is a small piece of server code, written in TypeScript or JavaScript, that runs only when something calls it, either a direct web request to your site or a platform event like a form submission. It doesn't run continuously and doesn't need a server you manage; Netlify runs it on demand and scales it automatically.

import type { Config, Context } from "@netlify/functions"

export default async (req: Request, context: Context) => {
  const data = await req.json();
  // call your CRM's API here, with your API key stored
  // as an environment variable, never in the code itself
  return new Response("ok");
}

export const config: Config = { path: "/api/create-lead" };

Your form or site calls this function's path, the function makes the actual API call to your CRM or payment tool server-side (where your API keys stay hidden from visitors), and returns a response. This is the real reason you can't just do this from a visitor's browser directly: calling a CRM or payment API usually needs a secret key, and anything in your site's own client-side code is visible to anyone who opens their browser's developer tools.

What this actually costs

Netlify's current plans run Free ($0, 300 credits a month), Personal ($9/month, 1,000 credits), Pro ($20/month, 3,000 credits) and custom-priced Enterprise. Function compute is billed by actual runtime: 1 GB-hour of compute (one hour at the default 1GB memory allocation, or less time at higher memory) costs 10 credits, which Netlify prices at roughly $0.07. For context, a lightweight function that runs for half a second per call, which is typical for a simple API relay, uses a tiny fraction of that per invocation; you'd need a very high volume of calls before compute cost became a meaningful line item next to your plan's base price.

Memory defaults to 1024MB per function, adjustable up to 4096MB on Pro and Enterprise plans if your function needs more headroom (processing larger payloads, for instance). Function logs are kept for a limited window and visible in your site's dashboard, useful for debugging when a call to the CRM or payment tool fails and you need to see why.

What I'd actually tell you

If your actual need is "move data from A to B when X happens," with no real logic, don't write a function. Use Zapier or Make; it's faster to set up, easier to change later without touching code, and you won't be the one debugging it at 11pm when it breaks. Functions earn their complexity when there's genuine logic involved, when you need to keep an API key secret, or when the no-code chain has already started feeling fragile with three or four conditional steps stacked on top of each other.

The honest tell that you've outgrown no-code: you've built a Zap or a scenario that works, but every time something changes upstream (a new field, a renamed status), you're afraid to touch it because you're not sure what else it'll break. That fragility is the real cost of no-code at scale, even though each individual step looked simple when you built it.

A worked example: a booking widget that needed real validation

A small clinic wanted its website booking form to check real-time slot availability against their scheduling software before confirming an appointment, rather than letting a customer book a slot that had already filled up in the few minutes since the page loaded. A pure no-code chain could technically attempt this, trigger a lookup, branch on the result, write back a confirmation, but with three or four conditional steps stacked together, it became fragile: a field renamed in the scheduling software's API broke the lookup step silently, and nobody noticed until a customer complained about a double-booked slot days later.

The fix was a single Netlify function sitting between the booking form and the scheduling software's API: it checks availability, confirms the slot is genuinely open, and only then writes the booking, all in one predictable piece of code with proper error handling instead of a chain of brittle no-code steps. When the scheduling software's API changed a field name months later, the fix was a one-line code change in a function with clear error logs, not a scavenger hunt through several connected no-code steps trying to figure out which one silently stopped working.

When to skip this and get help

Functions need someone comfortable writing and deploying code; this genuinely isn't a no-code option the way Netlify Forms or redirects are. If you don't have that in-house and the integration is a one-off, a freelance developer building a small, focused piece of API glue is often more cost-effective than you maintaining code you can't update yourself later.

How I'd approach this

I build exactly this kind of integration regularly: a website that needs to talk to a CRM, a payment processor or a booking system, with real logic and validation in between, running on Netlify's own functions rather than a server you'd have to maintain yourself. If a no-code connector genuinely covers your need, I'll tell you that directly rather than building something you didn't need. Where it's worth a custom piece is when the logic is real, or when you're joining data from more than one source before it goes anywhere.