I built a pay-to-email service where every email costs a penny

The problem nobody has solved

About 300 billion emails are sent every single day. Roughly 45% of them are spam. That's 135 billion unwanted messages flooding inboxes worldwide, every 24 hours.

Spam filters have gotten better over the years — Gmail does a decent job — but the fundamental economics of email haven't changed since 1971. Sending an email costs nothing. Zero. And when something costs nothing to send, people send a LOT of it.

I kept thinking: what if we attacked the problem at the protocol level, not the filter level?

The idea: make email cost $0.01

This isn't a new concept. Economists have proposed "email postage" for decades. The logic is simple:

• If sending an email costs $0.01, a normal person sending 50 emails/day pays $0.50. Negligible.
• A spammer sending 1 million emails/day pays $10,000. Unprofitable.
• At current global spam volumes (135 billion/day), spammers would need $1.35 billion per day just to operate.

The idea is elegant. Nobody implemented it well because you can't change SMTP. But you CAN build a layer on top of it.

So I built email35.

How email35 works

You sign up and get a [e-mail] address. You share this address publicly — on your GitHub profile, your Twitter bio, your website, wherever.

When someone wants to email you, they go through a simple flow:

1. They send an email to [e-mail]
2. They receive an auto-reply with a payment link
3. They pay $0.01 (crypto) or $0.50 (card)
4. Their email gets forwarded to your real inbox

That's it. The penny is a spam filter. If someone actually wants to reach you, $0.01 is nothing. If someone wants to blast 10 million people, $100K is everything.

The dashboard

Once you start getting emails, you manage senders from a simple dashboard with three actions:

• Allow Once — let this specific email through without payment (one-time)
• Whitelist — this sender never has to pay again (for people you know)
• Block — reject all future emails from this sender

The whitelist is key. Your colleagues, friends, and regular contacts get added once and never deal with the payment wall again. The penny gate only applies to cold outreach — which is exactly where spam lives.

Technical architecture

Here's how it's built under the hood:

Inbound email: Resend

I use Resend for inbound email handling. When an email arrives at *@email35.com, Resend catches it via MX records and fires a webhook:

// Netlify Function: handle inbound email webhook
export async function handler(event) {
  const payload = JSON.parse(event.body);
  const { from, to, subject, html, text } = payload;

  const recipient = to.split('@')[0];
  const sender = from;

  // Check if sender is whitelisted
  const status = await getSenderStatus(recipient, sender);

  if (status === 'whitelisted') {
    await forwardEmail(recipient, { from: sender, subject, html, text });
    return { statusCode: 200 };
  }

  if (status === 'blocked') {
    return { statusCode: 200 }; // silently drop
  }

  // Queue email and send payment link
  await queuePendingEmail(recipient, sender, { subject, html, text });
  await sendPaymentRequest(sender, recipient);

  return { statusCode: 200 };
}

Backend: Netlify Functions

The entire backend runs on Netlify Functions — serverless, zero infrastructure to manage. Endpoints handle:

• Inbound email webhooks
• Payment verification
• Email forwarding
• Dashboard API (whitelist/block/allow)
• Stripe webhook processing

Crypto payments: Base and Solana

For the $0.01 payment, crypto is the only option that makes sense at that price point (Stripe's minimum is much higher, hence the $0.50 card option).

Payments are accepted in USDC on two chains:

Base (Ethereum L2):

// Simplified payment contract on Base
contract Email35Payment {
    IERC20 public usdc;
    uint256 public constant PAYMENT_AMOUNT = 10000; // $0.01 (6 decimals)

    mapping(bytes32 => bool) public paid;

    function payForEmail(bytes32 emailHash) external {
        require(!paid[emailHash], "Already paid");
        require(
            usdc.transferFrom(msg.sender, address(this), PAYMENT_AMOUNT),
            "Transfer failed"
        );
        paid[emailHash] = true;
        emit EmailPaid(emailHash, msg.sender);
    }
}

Solana: Similar logic using a Solana program with USDC SPL token transfers.

Base gives us sub-cent transaction fees. Solana similarly. The sender pays $0.01 for the email plus a fraction of a cent in gas. Totally viable.

Fiat payments: Stripe

For people who don't have crypto wallets (most people, honestly), there's a Stripe Checkout option at $0.50. The higher price covers Stripe's fixed fee ($0.30 + 2.9%). Not ideal, but it's the cost of traditional payment rails at micro-transaction scale. This is honestly one of the best arguments for crypto — try moving $0.01 through Visa.

Payment verification and forwarding

Once payment is confirmed (on-chain event or Stripe webhook), the queued email gets forwarded:

async function onPaymentConfirmed(emailHash) {
  const pending = await getPendingEmail(emailHash);
  if (!pending) return;

  const recipientConfig = await getUserConfig(pending.recipient);

  await resend.emails.send({
    from: `${pending.senderAddress} via email35 <[e-mail]>`,
    to: recipientConfig.forwardTo,
    subject: `[email35] ${pending.subject}`,
    html: pending.html,
  });

  await markDelivered(emailHash);
}

Why $0.01 actually kills spam

Let's do the math properly.

A spammer's business model works because sending email is free. Their conversion rate is abysmal — typically 0.001% to 0.01%. But when you send 10 million emails for $0, even that tiny conversion rate is profitable.

Now add a penny:

Emails sent	Cost at $0.01/ea	Conversion (0.01%)	Revenue needed/convert
10,000	$100	1 conversion	$100+ to break even
1,000,000	$10,000	100 conversions	$100+ each
100,000,000	$1,000,000	10,000 conversions	$100+ each

Most spam (pills, phishing, Nigerian princes) doesn't generate $100 per conversion. The economics collapse instantly.

At the macro level: 135 billion spam emails/day × $0.01 = $1.35 billion/day. The entire global spam industry doesn't generate that in a year.

Who is this for?

• Public figures who share an email publicly and get buried in noise
• Open source maintainers who want to be reachable but not drownable
• Customer support inboxes where the penny acts as a seriousness filter
• Anyone with a public-facing email who wants signal, not noise
• Freelancers and consultants who want cold outreach to carry a small cost of intent

You don't replace your primary email. You use email35 as your public email — the one you post on websites and social profiles. Your real email stays private and clean.

What I learned building this

A few takeaways:

1. Micro-payments are still hard in fiat. Stripe's minimum fees make $0.01 impossible on traditional rails. This is genuinely a problem crypto solves well.

2. The UX has to be dead simple. If a sender has to do more than click a link and tap a button, they won't bother. The payment flow needs to be 10 seconds or less.

3. Whitelisting is non-negotiable. Without it, you're just adding friction to everyone. With it, you're adding friction only to strangers — which is exactly the point.

4. People underestimate how powerful a penny is. It's not about the money. It's about the proof of intent. A penny separates "I actually want to talk to you" from "I'm blasting 50,000 inboxes."

Try it

email35.com is live. Sign up, get your address, and put it in your bio.

The code processes real payments on Base, Solana, and Stripe. Emails actually forward to your inbox.

If you have questions or feedback, you know where to find me — just be ready to pay a penny.

---

Would love to hear what the dev community thinks. Is $0.01 the right price? Too low? Too high? Should there be a free tier for the first N emails? Drop your thoughts below.