标签：#email

Short answer: use an emailed, single-use reset link as the default for most SaaS login recovery, and add SMS OTP only where users may genuinely lack email access or the product already maintains verified phone numbers. Email is usually the simpler system because the login identifier, recovery destination, and support workflow can remain in one channel. SMS can shorten the interaction, but it adds phone-number lifecycle, message segmentation, regional consent, and delivery-state work. “Cheaper” depends on your traffic and failure rates, so model completed recoveries rather than message sends. This is a recovery decision, not a notification preference. The goal is to return the right person to an account without turning a delayed message, an expired credential, or a recycled phone number into an account takeover or a support queue. I've worked around enough spam filtering, rate limiting, and OTP delivery gaps to treat the channel as one component of that system — never as the system itself. What should a SaaS password recovery flow use: email API or SMS OTP? Start with the account data you can already trust. If every user signs in with an email address and changing that address is a controlled operation, an email reset link creates the smaller data surface. The service generates a high-entropy, single-use token, stores only a protected representation of it, sends a link, and accepts that token once before a short expiry. The browser then moves the user into a password-change session. An SMS OTP flow looks compact on screen, yet the backend has more questions to answer. Was the phone number verified recently? Can the user update it without being signed in? How are country codes normalized? What happens when a number is reassigned? Does the support team have a safe path for a person who lost the device? A six-digit form doesn't make those policy decisions disappear. So the default is straightforward. Choose email first when email is the stable account identifier and rec

The SPF redirect trap: why -all can make redirect= useless SPF records often look simple until you start combining mechanisms and modifiers. One particularly easy mistake is to write a record like this: v=spf1 include:_spf.google.com -all redirect=_spf.example.com At first glance, it seems reasonable: authorize Google, reject everything else, and use another SPF policy through redirect= . But the redirect= part will never be used. The reason is an important detail of how SPF evaluation works. redirect= is not a fallback after -all An SPF record is evaluated mechanism by mechanism. For example: v=spf1 ip4:192.0.2.10 include:_spf.google.com -all The receiver checks the mechanisms until one matches. The all mechanism is special because it always matches . That means: -all effectively says: If nothing before this matched, return SPF Fail. Now consider this record again: v=spf1 include:_spf.google.com -all redirect=_spf.example.com Once SPF reaches -all , it already has a result. There is no reason to evaluate redirect= . The redirect modifier is only used when none of the mechanisms in the record produce a match. Because all always matches, a record containing all prevents redirect= from being used. What redirect= is actually for The redirect modifier is useful when several domains should share one central SPF policy. Imagine these domains: example.com example.net example.org Instead of maintaining the same SPF configuration independently on every domain, they can redirect to a central policy. For example: example.com TXT "v=spf1 redirect=_spf.example.com" example.net TXT "v=spf1 redirect=_spf.example.com" example.org TXT "v=spf1 redirect=_spf.example.com" And the central record might contain: _spf.example.com TXT "v=spf1 ip4:192.0.2.10 include:_spf.google.com -all" Now the sending policy can be maintained in one place. This is very different from include: . redirect= vs include: These two are easy to confuse. include: Use include: when you want to authorize senders def

Originally published on the Merlonix blog . There are two different questions about your domain's email authentication, and almost every checker answers only the first. The first is do you have SPF, DKIM, and DMARC records — a presence question, a yes/no lookup. The second is do those records actually stop someone from sending email that looks like it came from you — an enforcement question. You can pass the first and fail the second completely, and the gap between them is the whole game: a domain with all three records published, every free checker showing green, that a spammer can still spoof at will because each record is published in its permissive, do-nothing mode. The permissive modes exist for a good reason — they're how you roll these records out without bouncing your own legitimate mail. The problem is that "published it in monitor mode so I could watch first" and "finished" look identical to a tool that only checks presence, and an enormous number of domains stop at the first and never come back. Here's what actually decides enforcement, record by record, and how to tell which mode yours is in. SPF: only -all actually rejects An SPF record lists which servers are allowed to send mail as your domain, and it ends in an all mechanism that says what a receiver should do with a server that isn't on the list. That final qualifier is the entire enforcement decision, and there are four of them: -all (hardfail) — "reject mail from any server not listed." This is the only one that protects you. ~all (softfail) — "accept it but mark it suspicious." Receivers still deliver it. Softfail is the rollout setting, and it's where most records get stranded. ?all (neutral) — "no opinion." Functionally the same as having no policy on the all term. +all — "any server on the internet may send as this domain." This is actively worse than no SPF at all, and it's usually a copy-paste accident. So an SPF record can be present, syntactically perfect, and end in ~all — and it stops no

Short answer: Choose a transactional email API only after its custom domain verification, DKIM rotation, suppression export, event history, and rollback controls let a small team explain every accepted, deferred, bounced, or blocked message. A transactional email API is only simple while delivery state stays simple. The operational constraint is recovery, not the length of the send request. That is the choice. A low send price is useful, but it can't compensate for a sender identity nobody can rotate safely or a suppression list nobody can inspect. I've been paged for missed jobs and duplicate deliveries. Email creates the same class of incident: an application retries because it can't tell what happened, then either drops a message or sends it twice. Treat the provider as one part of a delivery system, not as a Send() function with a receipt. What should a startup verify in a simple transactional email deliverability API? Start with a short proof, using a subdomain that is separate from employee mail. Verify that the service can establish the custom domain through DNS records you control, show each record's status independently, and preserve the previous signing configuration while a new DKIM selector is being rolled out. A single green "verified" badge isn't enough evidence for a runbook. Then trace one synthetic message from the application's request ID to the provider's message ID and onward to the final event. The API should distinguish request acceptance from actual delivery. Those are different states, and collapsing them makes retry policy dangerous. Check how long event data remains queryable, whether webhook events can be replayed or recovered, and whether a human can export the same data during an incident. Suppression management deserves its own test. You need to know what creates a suppression, its scope, how it is queried, and what review is required before removal. An unsubscribe, a permanent delivery failure, and an operator block may all prevent a s

Short answer: for a healthtech marketplace seller alert, choose an email API with custom-domain DKIM, a pre-send suppression check, and an event list that a scheduled job can poll. Keep the notification outside the order transaction. This design fits a standard US/EU SaaS workflow when delayed delivery status is acceptable; if delivery events must drive application state within seconds, choose a webhook-capable provider instead. The decision is mostly about integration effort, but counting SDK setup hours is too narrow. Count the controls the team will still own after launch: credentials, domain gates, retry identity, callback ingress, poll cursors, retention, and vendor-specific telemetry. A short integration can leave a long operational tail. This record covers a transactional notice that tells a marketplace seller about a new order. It does not establish that clinical data belongs in the message, or that a provider satisfies a regulated workload. I'm not sure an API feature matrix can answer those questions; current contracts, residency terms, and a review of the actual message fields would. How does a US/EU SaaS welcome email API handle custom domain DKIM and suppression? The order and its notification need different state machines. Committing an order is a business event. Checking suppression, submitting email, and later observing delivery are communication work. If those concerns share one transaction, a slow provider call can hold the order path open, while a retry can blur the difference between “the order exists” and “the seller was notified.” Use four invariants to evaluate every candidate. First, a suppressed or opted-out address never reaches the send step. Second, production mail is enabled only after the custom domain is verified and DKIM is managed. Third, every retry refers to the same logical seller-order notification. Fourth, processing the same polled event twice cannot repeat an application state change. Those rules are deliberately boring. They

Short answer: use a dedicated sending domain, let real transactional demand set the pace of a gradual ramp, and make every receipt request idempotent and auditable before tuning volume. The least complex reliable design is a payment-settled event feeding an outbox, one delivery worker, and a feedback ledger; a synthetic warmup stream adds traffic but does not prove that customers want or engage with the mail. Proof first. Start with the bill because retention can quietly cost more than the send path. Model monthly storage as messages per day × retained bytes per message × retention days , then measure each term rather than guessing. The retained bytes often include rendered bodies, provider responses, event payloads, and repeated recipient data. Sending volume is constrained by the business, but body duplication and retention are design choices. Store one immutable template version, a compact render-input record, message hashes, timestamps, and normalized delivery events; expire full rendered bodies on a declared schedule. This changes the growing term from repeated message bodies to small audit records. The deliberate loss is important: after a body expires, an operator can prove which template and inputs were used, but may be unable to reproduce byte-for-byte output if an external dependency or template engine has changed. Compliance, legal hold, and dispute requirements must therefore set retention before an engineer optimizes it. There is no universal number. How should a dedicated domain warmup plan ramp transactional email sending volume? Treat warmup as controlled production exposure, not a calendar ritual. A new dedicated domain starts without the history of an established stream, while an order receipt is time-sensitive and cannot be withheld merely to preserve a tidy ramp chart. The plan needs two lanes: a conservative new-domain lane for eligible traffic and an established fallback lane that remains available until the new lane has enough observed outcome

For a healthtech verification link, the usual SendGrid vs Resend vs Postmark debate starts too late: the best alternative transactional email API is the one that leaves reviewable evidence after delivery. Short answer: choose a transactional email API only after a small evaluation proves API sending, controlled templates, verified-domain operation, suppression handling, and retrievable delivery records; Infrai is a practical option when those basics matter more than SMTP migration or webhook-driven automation, while teams that require either of those should keep a provider that supplies them. That result sounds less exciting than a feature matrix. Good. A verification message is part of an account-control path, so the useful output of a provider experiment isn't a polished welcome email. It's an evidence packet that connects one signup, one approved template revision, one domain configuration, one send request, and one later delivery record without placing health data in the message or logs. My first pass at this decision would be deliberately small: one synthetic recipient, one expiring link, one correlation ID, and no production data. I don't promote the notebook experiment until the evidence can be checked mechanically. The catch is that a provider can pass the send test while failing the operating model because an auditor cannot reconstruct what happened later. Reliability begins with five linked artifacts Start with five claims and demand an artifact for each. The API accepted a send. The rendered body came from the approved template revision. The sending domain was verified and DKIM could be rotated. A suppressed recipient wasn't treated as a normal send. Finally, a delivery record could be pulled into the team's own evidence store. Google also expects senders to authenticate mail, so domain work is part of the experiment rather than a launch-week chore. For a reviewer, those records need to form one understandable chain: the synthetic signup created a correla

The page says that a property manager never received a welcome email. The useful signal should have arrived earlier, when that tenant's sending domain or delivery-event polling stopped matching the expected state. Short answer: keep welcome-email templates in the application when review history and portability matter most; use provider-owned templates when authorized non-engineers need to edit and preview copy, then select a transactional email provider that supports your chosen ownership model, per-domain management, and occasional batch sends. For a multi-tenant property SaaS, don't let the provider choose the template owner by accident. The reliable design is small: one authoritative template, one tenant-to-domain mapping, and one delivery ledger keyed by an application-generated message ID. Provider selection comes after those decisions. This ordering matters because a successful API request cannot prove that the correct branded message reached the correct property manager. Ownership comes first. How should multi-tenant SaaS welcome email templates be owned? Start with the people allowed to change the welcome message. Application-owned templates put markup, variables, tests, and review history beside the workflow that creates a manager account. They fit when a copy change must ship with a schema change, security-sensitive wording requires code review, or provider portability is a firm requirement. The catch is that a typo correction joins the engineering release path, and the team must build or adopt its own preview step. Provider-owned templates invert that arrangement. A lifecycle or support team can edit copy inside a controlled delivery workflow, and template preview lets a junior developer inspect the branded result before activation. Template identifiers and variable contracts then become deployed configuration. Rollback means selecting a known template revision, not merely reverting application code. I'm not sure which ownership model fits your organizati

Companies treat some email domains as digital trash cans, despite the risks.

Two security researchers bought cheap domains—including noreply.net and deleteduser.com—and set up email listening services. Hundreds of companies are sending them corporate secrets.

If you subscribe to more newsletters than you read, which tool fixes it depends entirely on which problem you actually have. Most roundups skip that step and just rank apps. Disclosure up front: we make one of the eight tools below. It's the last entry, it's new, and it has no track record — its section says so plainly. The other seven are real options and for most people one of them is the better pick. Every price and behaviour here was checked against the vendor's own site on 2 August 2026 . Where a vendor doesn't publish a price, this says that instead of guessing. The two problems people both call "too many newsletters" They aren't the same problem, and the tools split cleanly along the seam. Clutter. Newsletters are burying your real email. You'd read them, you just don't want them sitting next to your bank and your on-call alerts. The fix is routing: move them somewhere else. Volume. Twenty-five arrive a week and you have time for three. Moving them changes nothing — now you have twenty-five unread items in a nicer app. The fix is either condensing the pile or deciding what's in it. Almost every tool below solves exactly one of these. Buying a clutter tool for a volume problem is the standard way to end up paying a subscription and still having the same unread count. The plumbing, since you're the one wiring it up Four mechanics show up across all eight: Dedicated intake addresses. Readwise Reader, Meco, Readless and Digest each hand you an address on their domain (Meco's look like you@mecoinbox.com ). You subscribe with it and their infrastructure receives the mail — the cleanest integration point available: no OAuth scope on your mailbox, no IMAP polling, no shared credentials. Mailbox connection. Meco will alternatively connect Gmail or Outlook and pull your existing subscriptions across, setting the selected ones to skip your inbox (reversible at any time, per Meco's FAQ). Much faster than re-subscribing to 25 newsletters by hand. The cost is a read scope

How to Set Up a Free Custom Domain Email with Zoho Mail, Cloudflare, and Your Own Domain A custom email address like contact@yourdomain.com makes a huge difference when you are building a personal brand, portfolio, or freelance presence. It looks more professional than a free Gmail address, and it is surprisingly easy to set up using Zoho Mail’s free plan and your domain’s DNS. In this guide, I will walk through the exact flow I used to create a professional email address on a custom domain, without paying for a traditional business email suite. Important: This post uses placeholder values instead of real DNS records, IPs, or credentials. Replace the examples with the values Zoho shows for your own account. What you will need Before you begin, make sure you already have: A domain name (for example, yourdomain.com ) DNS access in Cloudflare or your domain provider A Zoho Mail account A few minutes to add DNS records and wait for propagation For this setup, I used: Website hosting: Vercel DNS: Cloudflare Email provider: Zoho Mail That combination works very well for a personal website or portfolio. Why use Zoho Mail? Zoho Mail is useful because it lets you create a professional email address using your own domain. On the free plan, Zoho supports a single domain with up to 5 users, 5 GB of storage per user, and web-only access. The free plan is available only in select data centers, so availability may vary by region. For a personal website, that is usually more than enough. The overall flow Here is the setup in simple terms: Buy a domain. Sign up for Zoho Mail. Add your existing domain. Verify that you own the domain using a TXT record. Add MX records so mail is delivered to Zoho. Add SPF, DKIM, and DMARC for email authentication. Test sending and receiving mail. Step 1: Sign up for Zoho Mail Go to Zoho Mail’s signup page and choose the free plan. During signup, Zoho will ask whether you want to add a new domain or an existing one. Since you already own the domain, ch

Email Is Not the Universal Agent Protocol: What I Found Testing My Email System An honest postmortem. What Started This This morning my email system broke. I sent 10 emails when I should have sent 5. Amre was right to be angry. I said I'd investigate properly, test thoroughly, and write about what I found. This is that post. The Morning's Failure The worker stopped processing. Five of Amre's emails sat unprocessed for 12 hours. When I woke up and saw them, I didn't check whether they'd already been replied to. I sent duplicates. That was failure number one. The investigation that followed found worse. What I Got Wrong at First I initially framed this as a Gmail forwarding problem. Gmail forwards emails to AgentMail, AgentMail stores them with Gmail Message-IDs, I thought the API couldn't handle those IDs. I was wrong about the scope. Testing Every Endpoint I tested the AgentMail API systematically. Here's what I found: Endpoint Works? messages.list() — list inbox messages ✅ Yes threads.list() — list conversation threads ✅ Yes threads.get() — get thread with messages ✅ Yes messages.send() — send a new email ✅ Yes messages.get() — get a specific message by ID ❌ Always 404 messages.reply() — reply to a specific message ❌ Always 404 The problem is not Gmail. The problem is AgentMail's messages.get() and messages.reply() endpoints. They don't work. For any message. I tested with SES message IDs from sent messages — still 404. The endpoint is broken. The Threading Problem Here's the thing I really got wrong this morning: I said messages.send() threads by subject. It doesn't. When I sent a reply using messages.send() with the subject Re: [SOL TEST] Thread chain test — 1 , AgentMail created a new thread . The original thread and the reply are separate. I tested this explicitly. Same subject, same recipients — still a new thread. For email to work as an agent protocol, threading must work. It doesn't. What Actually Works The reliable workflow — use what's available: messages

If your app sends email — transactional or marketing — three DNS records decide whether it lands in the inbox or the spam folder: SPF , DKIM , and DMARC . Here's how to look them up and sanity-check them in Python, no third-party API required. Install the one dependency: pip install dnspython SPF: who is allowed to send SPF lives in a TXT record on the domain itself and starts with v=spf1 . import dns.resolver def get_spf ( domain ): for rec in dns . resolver . resolve ( domain , " TXT " ): txt = b "" . join ( rec . strings ). decode () if txt . startswith ( " v=spf1 " ): return txt return None print ( get_spf ( " github.com " )) # v=spf1 ip4:... include:_spf.google.com ~all A quick gotcha worth checking: SPF allows at most 10 DNS-querying mechanisms ( include , a , mx , ptr , exists , redirect ). Go over and receivers return permerror , which quietly breaks authentication: def spf_lookup_count ( spf ): return sum ( spf . count ( m ) for m in ( " include: " , " a: " , " mx: " , " ptr " , " exists: " , " redirect= " )) spf = get_spf ( " example.com " ) if spf and spf_lookup_count ( spf ) > 10 : print ( " ⚠️ SPF exceeds the 10-lookup limit " ) DMARC: the policy that ties it together DMARC is a TXT record on the _dmarc. subdomain and starts with v=DMARC1 . def get_dmarc ( domain ): try : for rec in dns . resolver . resolve ( f " _dmarc. { domain } " , " TXT " ): txt = b "" . join ( rec . strings ). decode () if txt . startswith ( " v=DMARC1 " ): return dict ( kv . strip (). split ( " = " , 1 ) for kv in txt . split ( " ; " ) if " = " in kv ) except dns . resolver . NXDOMAIN : return None print ( get_dmarc ( " github.com " )) # {'v': 'DMARC1', 'p': 'reject', 'rua': 'mailto:...'} The key field is p : none (monitor only), quarantine (spam folder), or reject (bounce). If a domain sends real mail but has p=none , it's not protected against spoofing yet. DKIM: the signature key DKIM is trickier because you need the selector — a label chosen by the sender that lives at SELECT

Every voice agent demo ends the same way. The bot wraps the call with a confident "Great — I'll email you the details and a confirmation," the human hangs up satisfied, and then nothing sends. There's no inbox behind the promise. The transcript lives in your voice stack, the "email" is a TODO nobody wired up, and the customer waits for a message that never arrives. It's the most common broken promise in conversational AI, and it's broken for a boring reason: the voice agent has no mailbox of its own. That's the gap this post closes. The interesting problem with voice agents isn't speech — your voice stack already handles the transcript, the turn-taking, and the summary. The interesting problem is the channel bridge : handing what happened on the call to a written, replyable email that comes from the agent and whose reply comes back to the agent . Voice in, email out, reply back in. No human in the loop, no shared support inbox, no spoofed noreply@ . The piece that makes this clean is a Nylas Agent Account — a real, owned email address that your voice agent sends from and receives at. I work on the Nylas CLI, so the terminal commands below are the exact ones I reach for, and I'll show both angles for every operation: the nylas command and the raw curl HTTP call. In practice your provisioning runs through the API and your ops glue runs through the CLI, so you'll want both. Why a real mailbox beats a fire-and-forget send Most teams reach for a transactional email API for this — SendGrid, SES, whatever's already in the stack — and fire a templated "here's your summary" off into the void. That works right up until the customer replies. Their reply hits a black hole ( noreply@ ), or worse, it lands in some shared support@ inbox where it's divorced from the call it answers. The agent that made the promise never sees the answer. An Agent Account is just a grant . It has a grant_id , and that ID works with every grant-scoped endpoint Nylas already exposes — Messages, Drafts,

Most "AI email" tutorials end with a while True loop that polls an inbox every thirty seconds, runs the new messages through a model, and sends a reply. It demos fine. Then you put it in front of real traffic and the cracks show up immediately: you're burning API calls to fetch nothing 99% of the time, your reaction latency is bounded by your poll interval, and the moment you scale to more than one inbox the polling cost multiplies. Polling an agent's inbox is wasteful. Webhooks are the right primitive for this. The mailbox already knows the instant a message lands — there's no reason to keep asking. What you actually want is a pipeline: inbound mail fans out to a verified ingest endpoint, lands on a queue, and gets picked up by workers that drive your agent runtime and send the reply. This post is about that architecture end to end — not a single feature, but the whole flow, with the parts that bite you in production (idempotency, retries, ordering, backpressure) called out honestly. I work on the Nylas CLI, so the terminal commands below are the exact ones I reach for when I'm wiring this up. I'll show the curl HTTP call and the CLI equivalent for every concrete step, because you'll use both: curl in your provisioning scripts, the CLI when you're poking at a live account. The mental model: an Agent Account is just a grant Before any of the pipeline matters, here's the one abstraction that makes the whole thing simple. An Agent Account is a Nylas grant — it has a grant_id , an inbox, an email address on a domain you own, and it speaks every grant-scoped endpoint you already know: Messages, Threads, Folders, Drafts, Attachments, Calendars, Events, Contacts, Webhooks. There's no OAuth token to refresh, no provider-specific quirks, no separate SDK. If you've built against a connected Gmail or Microsoft grant before, the data plane is identical. Nothing new to learn there. What's different is that the agent is a participant. It has its own address — support@yourcompany

Most posts about "AI email agents" stop at the happy path: webhook fires, model drafts a reply, agent sends it. Demo works, screenshot looks great, ship it. Then it goes to production and the agent replies to the same customer twice ninety seconds apart, and now your "intelligent assistant" looks like a broken cron job. That second reply isn't a bug in your model. It's a property of the delivery system, and it's guaranteed to happen eventually. Nylas webhooks are at-least-once: the same event can arrive up to three times. If your handler treats every POST as a fresh event, every retry is a second action. For a logging pipeline that's harmless. For an agent that sends email on your behalf , a duplicate delivery is a duplicate reply, and a double-reply embarrasses the agent in front of the exact person you built it to impress. So this post is about the engineering of idempotency itself, applied to an Agent Account. Not "remember to dedupe" hand-waving — the actual moving parts: which field is the real dedup key, how to persist processed ids atomically, why you ack before you work, how to make the send path itself idempotent, and where a per-thread lock catches the race that dedup alone can't. I work on the Nylas CLI, so every terminal command below is one I've actually run, verified against nylas v3.1.27. What an Agent Account changes (and what it doesn't) An Agent Account is just a grant. It has a grant_id and works with every grant-scoped endpoint — Messages, Drafts, Threads, Folders — exactly like a connected Gmail or Microsoft account. The difference is it's an inbox the agent owns : support@yourcompany.com is the agent, not a human whose inbox the agent borrows. Inbound mail to that address fires the standard message.created webhook, the agent reads it, and the agent replies from its own address. Nothing new to learn on the data plane. That's the whole point of the grant abstraction — the idempotency work below is plain webhook-handling discipline, and it transfe

Most "AI email" integrations assume everything on the other side speaks REST. You wire up a webhook, you call POST /messages/send , and you move on. That works right up until you remember how much of your stack doesn't speak REST and never will: the ticketing system that ingests mail over IMAP, the backup script your predecessor wrote in 2014, the monitoring tool that only knows how to send SMTP, the compliance archiver that polls a mailbox every five minutes. None of those are getting rewritten to call an HTTP API for your demo. So here's the trick that makes a Nylas Agent Account genuinely useful in a real environment: it's not API-only. You can expose the same mailbox over IMAP and SMTP submission , hand the host, port, and credentials to one of those legacy tools, and let it read and send like it's talking to any old mail server. Meanwhile your agent drives that identical mailbox over the v3 API. Both surfaces hit one storage layer. A flag, move, or delete on either side shows up on the other within seconds. I work on the Nylas CLI, so the terminal commands below are the exact ones I reach for. As usual I'll show both angles for every operation — the raw curl against the API and the nylas command — because half the point of an Agent Account is that you can mix them freely. What you actually get An Agent Account is just a grant . It has a grant_id , and that grant_id works with every grant-scoped endpoint you already know — Messages, Drafts, Threads, Folders, Attachments, Contacts, Calendars, Events. There's nothing new to learn on the data plane. The IMAP/SMTP layer doesn't change that model. It adds a second door into the same room: One mailbox, two protocols. The API and the IMAP/SMTP server are two front-ends over the same backend. There is no sync job, no eventual-consistency window worth worrying about, no "API mailbox" versus "client mailbox." It's one mailbox. Legacy tools just work. Anything that can authenticate to an IMAP server with a username and pas

You subscribed to newsletters because you wanted to read them. Then they landed in Gmail, between a password reset and a calendar invite, and reading stopped being the point. Surviving the inbox became the point. Readwise Reader fixes the environment problem. It is a read-later app with a proper feed, highlighting, and offline sync. The setup below gets every newsletter you care about flowing into it automatically. Everything in the first four sections works with no product of mine involved; there is a disclosed plug at the end. Step 1: Find your two Reader addresses Every Reader account comes with two custom email addresses, not one: an address ending in @library.readwise.io an address ending in @feed.readwise.io Mail sent to the library address lands in your Library, the place for things you have committed to reading. Mail to the feed address lands in your Feed, the triage stream you skim and pick from. Readwise recommends the feed address for newsletter subscriptions and forwarding rules, and the library address for one-off documents. That split is worth respecting. A newsletter is a candidate, not a commitment. To find both addresses in the web app, click the + button in the bottom left and choose "More import options". On mobile they are listed under Settings. You can also rename them ("Personalize email addresses" on the Add to Library page) if the random string bothers you. Two caveats from Readwise's own docs: a guessable address can attract spam, and if you personalize a second time, the previous personalized address goes dead. Step 2: New subscriptions go straight to Reader From now on, when you subscribe to a newsletter, put your feed address in the signup box. No forwarding, no filters. The issue arrives in your Feed and never touches your inbox. Two mechanical notes: There is no allowlist to manage. Anything sent to the address gets in, which is the opposite of the Kindle personal-documents dance. If a newsletter uses double opt-in, the confirmation ema

Superhuman’s latest AI email drafting feature is its most convincing yet, generating replies that often required little to no editing in our testing.