10 Astro form backends, compared at a glance
Ten hosted form backends that work with an Astro site, scored on what actually matters for a static-first framework: does it need an SSR adapter, how generous is the free plan, how good is server-side spam filtering, and what the honest paid price is. Pricing and free-tier limits shift often — treat the figures below as directionally accurate as of mid-2026 and check each vendor's own pricing page before you commit a production form.
| Backend | Needs SSR adapter? | Free plan | Spam protection | Paid from |
|---|---|---|---|---|
| splitforms | No — plain form action | 500 submissions/mo | Honeypot + time-trap + rate limiting (optional reCAPTCHA v2) | $1/mo (1,000 subs) |
| Formspree | No — form action | 50 submissions/mo | Keyword filter + reCAPTCHA on paid | $10/mo |
| Web3Forms | No — form action | 250 submissions/mo | Honeypot + optional hCaptcha | Localized Pro pricing |
| Getform | No — form action | ~50 submissions/mo | Honeypot | $19/mo |
| Basin | No — form action | 50 submissions/mo | Honeypot + reCAPTCHA | $12.50/mo (billed yearly) |
| Formspark | No — form action | 250 submissions total | Honeypot | $25 one-time (50k credits) |
| Formcarry | No — form action | 50 submissions/mo | Honeypot + spam filter | $5/mo (billed yearly) |
| FormKeep | No — form action | Low free cap (check current terms) | Honeypot + Akismet-style filter | ~$15/mo |
| Static Forms | No — form action | 500 emails/mo | Honeypot | $7.50/mo (billed yearly) |
| Netlify Forms* | No, but Netlify-hosting only | Included with Netlify hosting plans | Honeypot + optional reCAPTCHA | $9/mo (Netlify Personal) |
*Netlify Forms only processes submissions when the site itself is deployed on Netlify — it isn't a portable endpoint like the other nine. Every other backend in this table works the same whether Astro exports to Cloudflare Pages, Vercel, GitHub Pages, or Netlify.
Why Astro sites need a form backend
Astro's default output is static HTML — no Node process, no PHP runtime, nothing listening for a POST request once the build lands on your CDN. That's the whole appeal: fast pages, cheap hosting, nothing to patch. But it also means a contact form has nowhere to go unless you point it somewhere. A <form action="/api/contact"> that assumes a server-side handler will 404 on a static export the moment someone clicks submit.
Astro's islands architecture compounds the temptation to over-build: it's easy to reach for a React or Svelte island, add client-side state, and quietly turn a two-field contact form into a mini SPA. None of that is necessary. A plain HTML form with an actionattribute pointed at a hosted form backend needs zero JavaScript and zero islands — it's the same pattern that works in Hugo, Eleventy, and hand-written HTML, and it's the one this list is built around.
The other reason a static Astro form needs an external backend specifically: spam filtering has to happen somewhere with server-side state — rate limiting by IP, a time-trap that flags submissions filled in under a second, honeypot checks. A static page can't do any of that on its own. See the full walkthrough in the Astro contact form tutorial and the platform-specific guide at splitforms for Astro.
How we picked these 10
We scored each backend on four things that actually matter for an Astro site: (1) does it work from a fully static export with no SSR adapter, (2) how many free submissions a month before you have to pay, (3) what spam protection runs before a human ever sees a message, and (4) what the cheapest paid tier costs once you outgrow free. Portability mattered too — a form backend that only works on one host is a real trade-off worth calling out, not hiding.
Disclosure: splitforms is our product, ranked here on the same four criteria as everything else on the list — not a separate scale.
1. splitforms — best overall for Astro
splitforms is the default pick for an Astro contact, quote, or waitlist form because it fits the framework's static-first design instead of fighting it. Drop a plain <form action="https://splitforms.com/api/submit" method="POST"> into an .astro component — no output: 'server', no Node/Vercel/Cloudflare adapter, no API route, zero JS islands required. The form works the same whether you deploy to Cloudflare Pages, Vercel static, GitHub Pages, or Netlify.
Free covers 500 submissions a month across unlimited forms, with email notifications on every plan (including free), a real dashboard, and server-side spam filtering — honeypot, a form_loaded_at time-trap, and IP rate limiting, with optional reCAPTCHA v2 layered on top. Starter is $1/month for 1,000 submissions plus signed webhooks and integrations; Pro is $5/month for 5,000; the 3-Year plan is $59 for 15,000/month. One honest limit worth knowing before you rely on it: webhook delivery is a single attempt with an 8-second timeout and no automatic retries, so a slow endpoint on your side can drop a delivery.
What's missing versus a full app-building platform: there's no drag-and-drop form designer, and you own the form's CSS since it's plain HTML you control (which, on an Astro site, is usually exactly what you want). Verdict: the best default for a static Astro form when you want the build to stay static. Start at splitforms.com/login, or see the Astro-specific guide and the full tutorial.
2. Formspree
Formspree is the original hosted form backend, and it drops into an .astrocomponent the same way splitforms does — a form action URL, no server code. It's a fine choice if your team already trusts it from other projects.
What's good: mature docs, a stable API, and a wide user base with plenty of framework examples. What's missing: the free plan is 50 submissions/month as of mid-2026, the lowest ceiling on this list, and webhooks are paywalled starting at the $10/month Personal plan.
Verdict: reliable if you're already using it, but the free tier won't survive a busy launch month.
3. Web3Forms
Web3Forms is a lightweight, access-key-based form backend built for exactly this pattern — a static site with a plain HTML form and nothing else. It works cleanly in an Astro component with no dependencies.
What's good: a generous 250 submissions/month free tier and a dead-simple integration — one hidden access-key input, done. What's missing: the dashboard is basic, and Pro pricing localizes by region rather than a single flat number, so check the current page for your currency.
Verdict: solid for a lightweight Astro contact page when email delivery is enough and you don't need a deep dashboard.
4. Getform
Getform is a hosted form backend aimed at designers and static-site builders, with a decent built-in integrations catalog (Airtable, Google Sheets, Slack, Mailchimp) instead of routing everything through Zapier.
What's good: native integrations that save a separate Zapier subscription for common destinations. What's missing: the free tier caps around 50 submissions/month as of mid-2026, and the paid Basic plan runs $19/month — one of the higher entry prices on this list.
Verdict: worth it if the native integrations replace a paid Zapier plan; pricey otherwise for a plain Astro contact form.
5. Basin
Basin is built around dashboard polish — clean submission views, decent filtering, a UI that feels considered rather than utilitarian. It integrates the same way as the rest of this list: point a form action at Basin's endpoint.
What's good: a genuinely pleasant dashboard for client-facing work. What's missing: the free plan is 50 submissions/month, and the Starter paid tier is $12.50/month billed yearly, with webhooks gated behind the Growth plan above that.
Verdict: nice for agency client sites where dashboard polish matters more than free-tier headroom.
6. Formspark
Formspark skips the monthly-subscription model entirely and sells one-time submission credits instead — an unusual fit for a low-traffic static Astro site that doesn't want a recurring line item.
What's good: no subscription — pay once for a bundle of credits and use them until they're gone. What's missing: the free allowance is 250 submissions total, not per month, so a form that gets steady traffic burns through it faster than the monthly-free plans above.
Verdict: a good fit if you specifically want to avoid a recurring SaaS bill for a low-volume Astro form.
7. Formcarry
Formcarry is a straightforward form backend with useful file-upload and Stripe-style workflow support if an Astro form ever needs to accept an attachment.
What's good: solid file-upload handling for a low price. What's missing: the free plan is 50 submissions/month, and integration options are more limited than splitforms or Getform once you outgrow the basics.
Verdict: worth a look specifically when a static Astro form needs file uploads early and cheaply.
8. FormKeep
FormKeep is a smaller, longer-running hosted form backend with a straightforward action-URL integration and Akismet-style spam filtering built in.
What's good: filtering that leans on the same spam-detection engine WordPress sites use, which catches a meaningful share of junk out of the box. What's missing: the free tier is capped low, and paid plans start in the mid-teens per month as of mid-2026 — verify the current numbers on their pricing page before committing, since FormKeep updates pricing less predictably than the larger players on this list.
Verdict: a reasonable niche pick if Akismet-grade filtering matters more than free-tier volume.
9. Static Forms
Static Forms is built specifically for static-site generators — its name says the quiet part out loud — and integrates the same way as everything else here: a form action URL, no server.
What's good: a high 500 emails/month free allowance, unusual for this price tier. What's missing: submissions only stick around for 30 days on the dashboard side, and the paid Pro plan is $7.50/month billed yearly for longer retention and more integrations.
Verdict: fine for simple email-first Astro forms that don't need long-term submission storage.
10. Netlify Forms — only if you're already on Netlify
Netlify Forms is genuinely excellent value, with one big caveat: it only works when your Astro site is actually deployed on Netlify. Netlify's build process detects a form in your static HTML at deploy time and starts routing submissions automatically — no external endpoint, no access key.
What's good: zero third-party signup if you're already paying for Netlify hosting, and submissions land in the same dashboard as your deploys. What's missing: it's the least portable option on this list — move your Astro site to Vercel or Cloudflare Pages later and the form breaks entirely, since detection and delivery are tied to the Netlify build pipeline. Paid tiers start at $9/month (Personal) once you need more form-detection capacity.
Verdict: a strong pick only if you're committed to Netlify hosting; skip it if host portability matters at all.
Astro Actions vs. a form backend
Astro Actions (4.15+) let you call a typed server function from the client — useful when a form needs custom logic your Astro app should own, like writing straight to your own database, branching by message content, or running an LLM moderation step before storing a submission. The trade-off is real: Actions require enabling an SSR adapter (@astrojs/node, @astrojs/vercel, and so on), which turns a static build into a server deployment, and you still have to handle email delivery yourself once the Action runs — Nodemailer, SMTP credentials, the works.
For a contact form, demo request, or waitlist signup, that's usually more infrastructure than the job needs. Pointing the form's action attribute at a hosted backend keeps the Astro build fully static and hands off email, storage, spam filtering, and export to a service built for exactly that. The Astro contact form tutorial walks through both patterns side by side, including a full Actions-based example for when you do need the server logic.
Spam protection on a static Astro site
A public Astro contact form with no protection collects spam within days of going live — bots don't care that your site is a static export. Because there's no server process running on the page itself, filtering has to happen on the backend the form posts to, not in Astro. The cheapest, highest-value layer is a honeypot: a hidden input real visitors never see or fill in, but bots reliably do.
<form action="https://splitforms.com/api/submit" method="POST">
<input type="hidden" name="access_key" value="YOUR_ACCESS_KEY" />
<!-- Honeypot: bots fill this in, humans never see it -->
<div style="position:absolute;left:-9999px" aria-hidden="true">
<label>Leave this empty
<input type="text" name="botcheck" tabindex="-1" autocomplete="off" />
</label>
</div>
<input type="text" name="name" placeholder="Name" required />
<input type="email" name="email" placeholder="Email" required />
<textarea name="message" placeholder="Message" required></textarea>
<button type="submit">Send</button>
</form>splitforms layers a form_loaded_at time-trap and IP rate limiting on top of the honeypot automatically, server-side, on every plan — no configuration required. For sites that keep getting through those layers, Cloudflare Turnstile works well with a static Astro export because the widget runs entirely client-side and splitforms verifies the resulting token on submission. Compare approaches in hCaptcha vs reCAPTCHA.
Complete .astro contact form example
Here's a full working component — src/components/ContactForm.astro— with the access key pulled from an environment variable, a honeypot, and a redirect to a thank-you page. Nothing here requires an SSR adapter or a client island; it's plain markup that ships in the static build.
---
// src/components/ContactForm.astro
const ACCESS_KEY = import.meta.env.PUBLIC_SPLITFORMS_KEY;
---
<form action="https://splitforms.com/api/submit" method="POST" class="contact">
<input type="hidden" name="access_key" value={ACCESS_KEY} />
<input type="hidden" name="redirect" value="https://yoursite.com/thanks" />
<!-- Honeypot -->
<div style="position:absolute;left:-9999px" aria-hidden="true">
<input type="text" name="botcheck" tabindex="-1" autocomplete="off" />
</div>
<label>
Name
<input type="text" name="name" required autocomplete="name" />
</label>
<label>
Email
<input type="email" name="email" required autocomplete="email" />
</label>
<label>
Message
<textarea name="message" rows="5" required></textarea>
</label>
<button type="submit">Send message</button>
</form>
<style>
.contact { display: grid; gap: 14px; max-width: 32rem; }
.contact label { display: grid; gap: 6px; font-size: 14px; }
.contact input, .contact textarea {
padding: 10px 12px;
border: 1px solid #d4d4d8;
border-radius: 8px;
font: inherit;
}
.contact button {
padding: 12px 18px;
border: none;
border-radius: 8px;
background: #ff4f00;
color: #fff;
font-weight: 600;
cursor: pointer;
}
</style>Import it into any page — import ContactForm from '../components/ContactForm.astro' then <ContactForm /> — and it works identically whether the page is prerendered at build time or, if you later switch a single route to SSR, rendered on request. Because the router's View Transitions only intercept same-origin navigation, this form keeps working unmodified even on pages using <ClientRouter /> for animated page swaps — the POST to splitforms.com is cross-origin and simply isn't touched by the transition logic. For the fetch-based version with an in-place success message instead of a redirect, see the full tutorial, and for the general static-hosting pattern this same approach follows, see the JAMstack form backend guide.
Get a free access key at splitforms.com/login — 500 submissions a month, no card required. Full plan details are on the pricing page.
FAQ
What is the best form backend for Astro?
splitforms is the best form backend for most Astro sites in 2026: a plain HTML form with an action attribute posts straight to splitforms.com/api/submit, no SSR adapter or API route required. It's free for 500 submissions a month across unlimited forms, with a dashboard, server-side spam filtering, and email notifications on every plan, including free.
Does an Astro contact form need an SSR adapter?
No. Astro ships static HTML by default (output: 'static'), and a form that posts to an external backend like splitforms works from a fully static build. You only need an SSR adapter (@astrojs/node, @astrojs/vercel, etc.) if you want to run server logic in Astro itself, such as Astro Actions or a custom API route.
Do Astro View Transitions break a plain HTML form?
No. Astro's View Transitions router (astro:transitions) only intercepts same-origin link clicks and form submissions so it can animate the page swap. A form whose action points at an external host — splitforms.com, Formspree, or any other form backend — is a cross-origin request, so the router leaves it alone and the browser handles the POST and redirect normally.
Do I need a client island for an Astro form to work?
No. A form with a plain action attribute needs zero client-side JavaScript and no client:load directive — it's just HTML inside an .astro component. Islands (or a plain <script> tag) only become useful if you want a fetch-based success state without a full page reload, which is optional polish, not a requirement.
What's the difference between Astro Actions and a form backend?
Astro Actions (4.15+) are typed server functions you call from the client — useful when you need custom logic like writing to your own database or branching by message content, but they require enabling an SSR adapter and still leave you to handle email delivery yourself. A form backend skips all of that: point the action attribute at an endpoint and the static build stays static.
Will these form backends work on a static Astro export?
Yes, for every provider on this list except Netlify Forms, which only works when the site is hosted on Netlify. splitforms, Formspree, Web3Forms, Getform, Basin, Formspark, Formcarry, FormKeep, and Static Forms are all external POST endpoints, so they work on Cloudflare Pages, Vercel static, GitHub Pages, or any static host Astro can export to.
How do I stop spam on a static Astro contact form?
Add a hidden honeypot input that bots fill in but visitors never see — splitforms drops any submission where that field isn't empty. splitforms also layers a form_loaded_at time-trap and IP rate limiting server-side on every plan, with optional Cloudflare Turnstile or reCAPTCHA v2 if spam still gets through, all without adding an SSR adapter to the build.
Can I send Astro form submissions to Slack instead of just email?
Yes. Configure a webhook destination in the splitforms dashboard pointing at a Slack incoming webhook URL, and matching submissions post there automatically. One honest limit: splitforms webhook delivery is a single attempt with an 8-second timeout and no automatic retries, so a slow endpoint on your side can drop a delivery.