The form submission hit Baserow at 2:47 PM. A potential client, finally. The automation I'd set up was supposed to send an instant confirmation email. Instead, the webhook pointed at a Mailgun sandbox I'd forgotten to upgrade, the email bounced, and I didn't notice until the prospect followed up three days later asking if their message went through.

That was embarrassing. And entirely preventable.

We're the JustEmails team — built by Velocity Digital Labs, the same group behind ClickzProtect for click fraud detection and JustAnalytics for privacy-first analytics. We've covered n8n integration and Zapier workflows before, but Baserow and NocoDB deserve their own walkthrough.

They're the self-hosted Airtable alternatives. The ones the no-code-but-actually-technical crowd gravitates toward. And wiring them up to a transactional email API? Slightly different than the n8n approach. If you're comparing SMTP vs API for transactional email, the API route is almost always cleaner for webhook-based workflows.

This tutorial covers both platforms. Same destination (the JustEmails API), two different starting points. By the end, you'll have automated emails firing from your database whenever rows change, forms submit, or whatever trigger you need.

What You'll Have at the End

A working automation that sends transactional email from your custom domain whenever a Baserow automation or NocoDB webhook fires. The emails come from your verified domain with SPF/DKIM/DMARC authentication — not some generic relay address that screams "this is automated." You'll pull dynamic data from the database row that triggered the automation. Names, emails, statuses, whatever fields you've got.

Prerequisites

Before we start:

A JustEmails account with at least one verified domain — grab the 7-day trial if you're new. Our custom domain email setup guide covers DNS configuration in detail.
Your JustEmails API key (Dashboard → API → Keys)
Baserow instance (self-hosted or Baserow Cloud) with a table to trigger from, OR
NocoDB instance (self-hosted or hosted) with a base to trigger from
Basic familiarity with webhooks — you've seen JSON before and aren't scared of it
About 25 minutes

Quick note on API limits: JustEmails includes 1,000 transactional emails per month on the base $49/year plan. Database automations — row notifications, form confirmations, status alerts — typically stay well under that. Most people never hit it. If you're building something high-volume, add 10,000 emails/month for $25/year. Stack as needed.

Part 1: Baserow Automations

Baserow added automations in late 2024. Still maturing — I'll be honest, the UI is clunky compared to n8n — but the webhook action works reliably. Here's how to wire it to JustEmails.

Step 1: Create Your JustEmails API Key

Log into JustEmails. Go to Dashboard → API → Keys. Click "Create New Key."

Name it something recognizable. "Baserow Notifications" works. You'll thank yourself when you're auditing API keys six months from now and can't remember what "Key_7" was for.

Copy the key immediately — JustEmails only shows it once. Seriously, write it down somewhere. The format is je_live_xxxxxxxxxxxx. That live prefix means production; emails actually send. Test keys exist too (je_test_), but they don't deliver anywhere.

Step 2: Set Up the Baserow Table

You probably already have a table. If not, create one with at least these fields for testing:

Name (single line text)
Email (email field type)
Status (single select: Pending, Confirmed, Completed)

The automation will fire when Status changes to "Confirmed" — a common pattern for form submissions that need follow-up.

Step 3: Create the Automation

In Baserow, open your table. Click the lightning bolt icon (Automations) in the left sidebar.

Click "Create automation." Name it "Send confirmation email" or similar.

Trigger configuration:

Trigger type: When a row is updated
Table: your target table
Filter: Status → changed to → Confirmed

This is the important part. You don't want emails firing on every row edit. Trust me on this one — I once triggered 47 emails to a client because I was fixing typos in their contact record. Filters are your friend.

Step 4: Add the Webhook Action

Click "Add an action" after your trigger.

Select Send webhook. Configure it:

Setting	Value
URL	`https://api.justemails.app/v1/email/send`
Request method	POST
Header 1 name	Authorization
Header 1 value	Bearer je_live_your_key_here
Header 2 name	Content-Type
Header 2 value	application/json

For the body, use Baserow's field references to pull dynamic data:

{
  "to": "{{ row.Email }}",
  "from": "notifications@yourdomain.com",
  "fromName": "Your App",
  "subject": "Confirmed: {{ row.Name }}",
  "html": "<p>Hi {{ row.Name }},</p><p>Your submission has been confirmed.</p><p>We'll be in touch within 24 hours.</p>"
}

Replace yourdomain.com with your verified JustEmails domain.

(Here's the thing — Baserow's template syntax uses double curly braces like {{ row.FieldName }}. If your field name has spaces, use the internal field ID instead. Hover over the field in the automation editor to see available variables.)

Step 5: Test It

Create a test row. Set Status to "Pending." Save it. Then edit the row and change Status to "Confirmed."

Check your inbox. The email should arrive within seconds.

If it doesn't:

Check Baserow's automation logs (click the automation, then "Runs")
Look for HTTP error codes in the response
401 means bad API key — did you include Bearer with the space?
422 means unverified domain — add the domain in JustEmails Dashboard

Common mistake I made: forgetting that Baserow's field references are case-sensitive. {{ row.email }} won't work if your field is named Email. Forty-five minutes of debugging. Forty-five minutes I won't get back.

Part 2: NocoDB Webhooks

NocoDB's approach is different. It doesn't have a visual automation builder like Baserow. Instead, you configure webhooks directly on tables — they fire on record events and POST to your endpoint.

Step 1: Get Your API Key (Same as Above)

If you already did Part 1, skip this. Same JustEmails API key works for both platforms.

Step 2: Create the Webhook in NocoDB

Open your NocoDB base. Navigate to the table you want to trigger from.

Click the dropdown arrow next to the table name. Select Webhooks.

Click + Create Webhook.

Configure:

Webhook name: Send confirmation email
Event: After Insert (or After Update — your choice)
Condition: Add a filter if needed (e.g., Status equals "Confirmed")

For the request:

Setting	Value
Method	POST
URL	`https://api.justemails.app/v1/email/send`

Add headers:

Authorization: Bearer je_live_your_key_here
Content-Type: application/json

Step 3: Build the Request Body

NocoDB's webhook body needs a bit more manual work. You'll use handlebar-style templating with the record data.

In the Body section, select Custom payload and enter:

{
  "to": "{{Email}}",
  "from": "notifications@yourdomain.com",
  "fromName": "Your App",
  "subject": "Welcome, {{Name}}",
  "html": "<p>Thanks for signing up, {{Name}}.</p><p>You're confirmed. Here's what happens next...</p>"
}

Field names in NocoDB webhooks reference the column names directly — no row. prefix like Baserow.

Step 4: Test the Webhook

NocoDB has a "Test webhook" button. Click it.

But here's the catch — test mode sends sample data, not real row data. The field values will be placeholders. To truly test:

Save the webhook
Create a new row in your table with real data
Check your email

If the webhook fails, NocoDB shows the error in the webhook configuration panel. Common issues:

Connection refused: If self-hosting NocoDB in Docker, check that outbound HTTPS isn't blocked
401 Unauthorized: API key issue — same debugging as Baserow
422 errors: Domain not verified in JustEmails

Step 5: Handle Multiple Recipients (NocoDB Quirk)

NocoDB webhooks send the full row data. If you need to email multiple people per record — say, the submitter AND an internal team address — you'll need to make two webhook calls or use an intermediary.

The cleanest approach: route through n8n or Make. NocoDB fires a webhook to n8n, n8n splits the logic, n8n calls JustEmails twice. More moving parts, but proper error handling and retry logic. We covered the n8n + JustEmails setup in detail.

(Look, I like NocoDB. But its webhook system is fire-and-forget with no built-in retry. No error handling. No conditional logic. For mission-critical notifications, the n8n intermediary is worth the extra complexity. For "nice to have" alerts? Direct webhooks are fine.)

Common Errors and Fixes

"401 Unauthorized"

API key problems. Checklist:

Bearer prefix present? (Space after Bearer matters.)
Key is je_live_ not je_test_?
No extra quotes or whitespace around the key?

Copy fresh from JustEmails dashboard if unsure.

"422 Unprocessable Entity: from address not verified"

You're sending from a domain not set up in JustEmails. Add it in Dashboard → Domains, configure the DNS records (SPF, DKIM, DMARC — JustEmails auto-generates these), wait for verification. Usually takes under 5 minutes. Sometimes DNS propagation is slower. Grab coffee. Our custom domain setup guide has the full walkthrough.

"400 Bad Request: Invalid JSON"

Your payload has a syntax error. Most common causes:

Field references that return undefined (the field name is wrong)
Unescaped quotes in your message content
Missing commas between JSON fields

Check the webhook response body — JustEmails returns a specific error message pointing to the problem.

Webhook fires but email goes to spam

Annoying. Usually a domain reputation issue, not JustEmails specifically. But check your authentication:

Is SPF passing? Run your domain through MXToolbox.
Is DKIM signing correctly? JustEmails Dashboard → Domains shows this.
DMARC policy set? Even p=none helps initially. See our DMARC guide for the staged rollout approach.

Self-hosted instance can't reach api.justemails.app

Firewall or network config. Test from your server:

curl -I https://api.justemails.app

If that fails, check outbound HTTPS rules. Docker Compose setups sometimes need explicit network configuration.

Why Not Just Use Airtable?

If you're reading this, you probably already know.

Airtable works great — until you hit the row limits, or the per-seat pricing, or the API rate limits that throttle your automations at scale. I've been burned by all three. Baserow and NocoDB exist because people got tired of those constraints.

The tradeoff? Fewer native integrations. Airtable has Send Email and Slack and dozens of actions built in. Baserow and NocoDB give you webhooks and say "figure it out." Which is annoying but also kind of liberating. That's where this tutorial comes in.

(For what it's worth, I run a personal project tracker in Baserow specifically because I don't want per-seat pricing when I occasionally share views with contractors. Same logic applies to email — per-mailbox pricing adds up, which is why JustEmails does $49/year flat for unlimited mailboxes across unlimited domains. We break down the numbers in our flat-fee vs per-mailbox pricing analysis.)

Next Steps

You've got the basic automation working. Now what?

Multiple templates: For different notification types — welcome emails vs. status updates vs. alerts — duplicate the automation with different filters and HTML templates. The JustEmails API accepts whatever HTML you throw at it.

Richer HTML: Building emails in a JSON string gets messy fast. Escaping quotes, dealing with line breaks — not fun. Consider generating the HTML elsewhere (a GitHub gist, a template in your codebase) and fetching it. Or use n8n's Code node as an intermediary to build complex templates with actual styling.

Track opens and clicks: JustEmails webhooks can notify you on delivery, open, and click events. Useful for debugging deliverability or building engagement metrics back into your database. Configure in Dashboard → Webhooks.

Monitor your usage: Dashboard → API → Usage shows your transactional email count. The base plan includes 1,000/month — plenty for most database automation. If you're building something higher volume, the 10,000/month add-on at $25/year is cheaper than standalone transactional providers. See our Google Workspace alternatives roundup for how JustEmails stacks up on price.

Already using Zapier or n8n for other automations? The JustEmails HTTP pattern works identically in those tools. Mix and match.

Frequently Asked Questions

Do Baserow and NocoDB have native email sending features?

Neither Baserow nor NocoDB has built-in email sending. Baserow's automations and NocoDB's webhooks can only make HTTP requests to external services. That's where the JustEmails API comes in — you configure a webhook action to POST to the JustEmails endpoint with your email payload, and the API handles delivery with proper SPF/DKIM authentication.

Can I use JustEmails with the cloud-hosted versions of Baserow and NocoDB?

Absolutely. The JustEmails API works the same whether your database is self-hosted or cloud-hosted. Baserow Cloud and NocoDB's hosted offering both support webhook automations. The only difference is you don't control the server environment — but since JustEmails is a standard REST API over HTTPS, there are no port or firewall considerations.

How do I handle email failures in Baserow or NocoDB automations?

Baserow's automations don't have conditional branching yet, so failed webhook calls are logged but not automatically retried. NocoDB webhooks are fire-and-forget. For critical emails, route through n8n or Make first — those tools have proper error handling and retry logic. The JustEmails API returns detailed error codes (401, 422, 400) so you can debug failures in your automation logs.

What's the email sending limit when using JustEmails API from database automations?

JustEmails includes 1,000 transactional API emails per month on the base $49/year plan. For most database automation use cases — row update notifications, form submission confirmations, status change alerts — that's plenty. If you need more, add 10,000 emails/month for $25/year, stackable as needed.

Try JustEmails

Unlimited custom domain email hosting for $49/year flat — unlimited domains, unlimited mailboxes, 10 GB storage, full IMAP/SMTP. Built for agencies, freelancers, and anyone managing email across more than one domain.

Start your 7-day free trial → · How it compares

Connect JustEmails to Baserow and NocoDB for Database Email Automations