Why doesn't my v0, Lovable, Bolt, or Cursor contact form work?
v0, Lovable, and Bolt.new are generative UI tools — you describe a form, they return production-looking React, usually with Tailwind. Cursor writes the same kind of form on request. All four are good at the part you can see: inputs, validation, a styled submit button. None stand up a server by default — the generated onSubmit typically does nothing, logs to the console, or fakes a "thanks!" message that never sent anywhere.
It's not a bug — it's a scope boundary. A form is a front-end element; receiving a submission needs a backend that accepts a POST, stores it, and notifies someone, whether that's code you write (a Route Handler, a Supabase edge function) or a hosted service the form points at instead. For a contact, waitlist, or lead form — most of what AI-generated sites need — the hosted route is far less work, and it's what this article ranks.
Disclosure: splitforms is our product, ranked here on the same criteria as everything else — not a separate scale.
10 form backends for AI-generated contact forms, compared
Ten ways to catch a submission from a v0, Lovable, Bolt, or Cursor-built form, scored on what matters here: how much you change in the AI tool's chat or code, where the submission ends up, how much spam protection ships before you pay, and the cheapest paid tier. Pricing shifts often — treat this as directionally accurate for mid-2026 and check each vendor's own page before committing.
| Tool | Setup in the AI tool | Where submissions go | Spam protection | Paid from |
|---|---|---|---|---|
| splitforms | One prompt line or endpoint swap | Dashboard + email | Honeypot + time-trap + rate limiting (optional reCAPTCHA v2) | $1/mo (1,000 subs) |
| Formspree | Paste HTML action URL | Formspree dashboard | Keyword filter | $10/mo |
| Web3Forms | Paste endpoint + access key | Email + 30-day history on Free | Advanced protection + hCaptcha | Starter: 5,000/mo |
| Getform | Paste HTML action URL | Getform dashboard | Honeypot | $19/mo |
| Basin | Paste endpoint | Basin dashboard | Basic + Zapier | Scales by volume (check current pricing) |
| Formspark | Paste endpoint | Formspark dashboard | Basic | $25 one-time (50,000 subs, no expiry) |
| EmailJS | Client-side SDK, no server | Your inbox only | None built-in | ~$9/mo (2,000 requests) |
| Netlify Forms | Zero, but Netlify-hosting only | Netlify dashboard | Basic honeypot + optional reCAPTCHA | Included on Netlify plans (check current terms) |
| Supabase + edge function | Write table, function, email step | Your Supabase table | Whatever you build | Supabase cost + email provider |
| Custom API route | Write it yourself | Wherever you store it | Whatever you build | Your hosting + email provider |
*Formspark sells non-expiring submission bundles instead of a monthly subscription. Web3Forms Free includes 250 submissions/month and 30 days of history.
How we ranked these 10 form backends
This is scoped specifically to the AI-builder case, not static sites in general: a form v0, Lovable, Bolt, or Cursor already generated, where you want the smallest change to make it real. Four criteria: how much you touch in the chat or generated code, where the submission lands, spam protection before you pay, and the cheapest paid tier.
1. splitforms — built for exactly this gap
splitforms exists to fix exactly this gap. The fix is a single POST endpoint — https://splitforms.com/api/submit — that any generated form can target, whether it's v0's React + fetch pattern, Lovable's client component, Bolt's WebContainer app, or a form Cursor just wrote. In practice that's one prompt line pasted into the AI tool's chat: "point the form action at https://splitforms.com/api/submit with a hidden access_key field," leaving the existing design and markup untouched.
Free covers 500 submissions/month across unlimited forms, email notifications on every plan, spam filtering (honeypot, a form_loaded_at time-trap, rate limiting, optional reCAPTCHA v2), and a real dashboard — no credit card. Starter is $1/month for 1,000 submissions, signed webhooks (HMAC SHA-256, sha256= header), and 13 integrations. Pro is $5/month for 5,000, and the 3-Year plan is $59 for 15,000/month. One honest limit: webhook delivery is a single attempt with an 8-second timeout and no automatic retries — the stored submission and email notification are unaffected either way.
What generic form backends don't have: a native MCP server. An agent in Cursor or Claude Code can create a form on your account, fetch your real access key, and generate wired-up code through a typed protocol instead of a copy-pasted dashboard key — see AI agent form backend and ChatGPT form backend. Verdict: the best default for any v0, Lovable, Bolt, or Cursor-generated form — one endpoint, no server code. Get a free key at splitforms.com/login.
2. Formspree — the original hosted form backend
Formspree predates the AI-builder wave by years but works the same way for a v0, Lovable, or Bolt form as it does for plain HTML: paste its action URL in and submissions route through Formspree's dashboard. It's mature, well-documented, and widely recognized, which matters if you want a name a client or teammate already trusts.
What's good: a stable, long-running API and solid docs. What's missing for this use case: the free tier is 50 submissions/month — a tenth of splitforms' free volume — and webhooks are paywalled starting at the $10/month Personal plan, ten times splitforms' Starter price for a comparable feature.
Verdict: fine if you're already using it elsewhere, but the free tier won't survive a busy launch week for a new AI-generated site.
3. Web3Forms — 250 free submissions with 30-day history
Web3Forms is a lightweight, access-key-based form-to-email API — request a key, paste it into a hidden field, POST to their endpoint. Its free tier allows 250 submissions/month, five times Formspree's free allowance.
What's good: 250 submissions/month, unlimited forms and domains, advanced spam protection, hCaptcha, custom redirects, and 30 days of history. What's missing on Free: webhooks, file uploads, the Submissions API, reCAPTCHA, Turnstile, and integrations.
Verdict: a reasonable free option when 30 days of history is enough; compare paid retention and integration needs before committing.
4. Getform
Getform is a hosted form backend shaped like splitforms and Formspree — paste an HTML action URL, submissions land in Getform's dashboard. Its native integrations catalog (Airtable, Sheets, Slack, Mailchimp) beats routing through Zapier.
What's missing: the free tier caps around 50 submissions/month, and the cheapest paid plan is $19/month — the highest entry price on this list, splitforms included.
Verdict: worth it if the native integrations save you a Zapier subscription; expensive otherwise for a simple AI-generated contact form.
5. Basin
Basin is a no-code-leaning form backend with a built-in Zapier connector. Spam submissions are filtered server-side and don't count against your monthly quota.
What's good: a useful free tier for testing (1 form, 50 submissions/month, 30-day retention). What's missing: paid tiers scale by volume — check Basin's current pricing page for exact break points.
Verdict: a solid lightweight pick for a low-volume AI-generated site, especially if Zapier is already part of your stack.
6. Formspark
Formspark breaks from monthly subscriptions entirely: every account starts with 250 free submissions as a one-time allowance, not a monthly reset. The paid upgrade is a one-time $25 payment for 50,000 submissions that never expire.
What's good: for a low-traffic v0 or Lovable portfolio, paying once and forgetting it is appealing. What's missing: the free allowance doesn't reset monthly — easy to misread as "250/month" and get surprised when it runs out early.
Verdict: a good fit if you want to pay once and forget about it; a poor fit if you were expecting a recurring monthly allowance.
7. EmailJS
EmailJS takes a different approach: its client-side SDK sends email straight from the browser through your own email account or SMTP relay. No server-side storage at all — the message lands in your inbox or it's gone.
What's good: no server component, fitting a fully static AI-generated site. What's missing: no dashboard, no built-in spam filtering, and a small free tier — 200 requests/month, ~$9/month for 2,000 on Personal.
Verdict: reasonable only if you want literally nothing but an email and are comfortable losing the submission if delivery fails.
8. Netlify Forms — only if the generated site deploys to Netlify
Netlify Forms is the one entry here that isn't general-purpose — it only works if your export is actually deployed to Netlify, and Netlify's build-time bot needs to detect the raw form HTML, which React-rendered forms don't always expose without a hidden static duplicate. v0 deploys to Vercel by default, so this option is off the table there.
What's good: zero third-party setup if your hosting is already Netlify. What's missing: it's tied to one host, JS-rendered form detection is finicky, and Netlify's forms pricing has changed more than once recently — verify current terms before counting on a specific submission cap.
Verdict: the right call only inside a fairly narrow lane — a Netlify-hosted, mostly-static export with a detectable form.
9. Supabase table + edge function (DIY)
This is Lovable's own default suggestion: create a Supabase table, write an edge function to receive the POST, and wire in an email provider like Resend. It's legitimate, and the right call when the form's data is genuinely part of your app.
What's missing for a plain contact or lead form: three separate pieces you now own — a schema and RLS policy, a deployed function, and a second vendor account with its own API key — plus spam filtering and a dashboard you'd build yourself. That's a lot of maintenance for "email me when someone fills out a form."
Verdict: right when the submission belongs in your own database; overbuilt for a contact form that a hosted endpoint already solves in one line.
10. Custom API route (DIY)
The fully manual option: write a Route Handler or serverless function, validate the body, call an email provider, handle spam yourself. v0, Bolt, and Cursor can all scaffold the skeleton — but you own maintaining it.
What's good: total control over the code and where data lives. What's missing: everything a hosted backend gives free — dashboard, spam filtering, webhook fan-out — has to be built and kept working by you.
Verdict: appropriate when the form is core product infrastructure, not a marketing contact form; overkill glue code otherwise.
So which one should you actually pick?
- Building with v0, Lovable, Bolt, or Cursor, want the smallest change: splitforms — one endpoint, free tier covers most sites.
- Already using Formspree elsewhere: keep it, budget for lower free volume and a paid webhook gate.
- Want 250 free submissions with hCaptcha and 30-day history: Web3Forms.
- Deploying specifically to Netlify: Netlify Forms, if the form survives as static HTML.
- Form data belongs in your own app database: Supabase + an edge function, or your own API route.
- Driving forms from an AI agent, not a chat prompt: splitforms' MCP server.
If undecided, start with splitforms' free tier — it costs nothing to test. Grab a key at splitforms.com/login.
How do you actually wire the fix into v0, Lovable, Bolt, or Cursor?
The pattern is identical across all four: keep every generated component as-is, change only where the submit handler sends data. Each tool has its own idiom and its own full walkthrough below.
v0 (Vercel)
Drop this handler into v0's generated component without touching the markup:
const data = new FormData(e.currentTarget);
data.append("access_key", ACCESS_KEY);
const res = await fetch("https://splitforms.com/api/submit", {
method: "POST",
body: data,
});Full walkthrough: add a form backend to a v0 app.
Lovable
Lovable's default advice is Supabase + Resend + an edge function. Paste this into Lovable's chat instead:
Change the contact form so that on submit it sends the form data
as a POST request to https://splitforms.com/api/submit using fetch.
Include a hidden field "access_key" with the value "YOUR_ACCESS_KEY".
Do not change the visual design or styling of the form.Full walkthrough: add a working contact form to a Lovable app.
Bolt.new
Bolt's generated form usually shows a success toast without delivering anything. Same prompt pattern, inside Bolt's chat:
Change the contact form so that on submit it POSTs the form data
to https://splitforms.com/api/submit via fetch, including a field
"access_key" set to "YOUR_ACCESS_KEY". Keep all existing styling
and validation.Full walkthrough: add a working contact form to a Bolt.new app.
Cursor
The same one-line prompt works for a quick fix. For account-aware setups, connect the splitforms MCP server so the agent creates the form and pulls your real key instead of guessing:
npx @splitforms/mcp install --token sk_mcp_xxxxxxxxxxxxFull walkthrough: add a form backend in Cursor with the splitforms MCP.
FAQ
Why doesn't my v0, Lovable, or Bolt contact form submit anywhere?
Because these tools generate UI, not backends. v0, Lovable, and Bolt.new all produce polished React/Tailwind form components, but the onSubmit handler is usually a placeholder that logs to the console or fakes a success state. Nothing is stored and nobody's notified until you point that handler at a real endpoint — code you write, or a hosted form backend.
Is splitforms' free tier enough for an AI-generated site's contact form?
For most personal sites and small-business pages built with v0, Lovable, Bolt, or Cursor, yes. Free covers 500 submissions/month across unlimited forms, with email notifications on every plan, a dashboard, and spam filtering — no credit card. Starter is $1/month for 1,000 submissions plus signed webhooks and 13 integrations; Pro is $5/month for 5,000; the 3-Year plan is $59 for 15,000/month.
Do splitforms' signed webhooks retry if my endpoint is down?
No, and it's worth knowing before you rely on one. Webhook delivery is a single attempt with an 8-second timeout — no automatic retries. If your destination is slow or briefly down, that delivery is dropped. The submission itself is never lost; it's always stored in the dashboard and still emails you, but a webhook consumer needs to be reasonably fast and available.
Is it safe to paste my splitforms access key into a v0, Lovable, Bolt, or Cursor prompt?
Yes. The access key is a public identifier meant to live in client-side code — the same model Formspree, Web3Forms, Getform, and every hosted form backend on this list uses. It isn't a secret. Abuse is prevented server-side with rate limiting, an Allowed Domains setting, and spam filtering, and you can rotate a key from the dashboard in one click if it's ever misused.
Can Netlify Forms handle a form generated by v0, Lovable, or Bolt?
Only if the generated site is actually deployed to Netlify, and the form markup survives as static HTML at build time. v0 deploys to Vercel by default, so Netlify Forms is off the table there. Lovable and Bolt exports can go to Netlify, but both render forms client-side in React, which Netlify's build-time parser doesn't always detect without a hidden static duplicate of the form.
What does the splitforms MCP server add beyond pasting a prompt line?
For a one-off form, pasting a prompt telling the AI tool to POST to splitforms.com/api/submit works fine. MCP matters when an agent in Cursor or Claude Code needs live account context — creating a real form, fetching your actual access key, or reading submissions to debug — through a typed protocol instead of a guessed key.