Make Laravel SMTP emails show up in the "Sent" folder (raw IMAP APPEND, no library)

Marco Caciotti — Sat, 01 Aug 2026 19:26:30 +0000

You wired up transactional email in Laravel, Mail::to($user)->send(...) works, the message lands in the recipient's inbox. Then you open the sending account in Roundcube (or Apple Mail, or any IMAP client) and… the Sent folder is empty.

Nothing is broken. This is just how email works — and the fix is a single IMAP command most people have never used: APPEND.

Here's the whole thing, with no extra Composer dependency.

Why SMTP send ≠ a copy in "Sent"

Sending and storing are two different protocols:

SMTP hands your message to a mail submission agent, which relays it to the recipient. That's it. SMTP has no concept of your mailboxes.
IMAP is where your folders (Inbox, Sent, Drafts…) actually live.

When you send from a desktop client, the client quietly drops a copy into Sent over IMAP. Your Laravel app isn't doing that step, so there's no copy to show.

Two "solutions" that look right and aren't:

BCC yourself — the copy arrives in Inbox, not Sent, and every message shows you as a recipient. Ugly.
A Sieve rule — Sieve filters incoming mail. Outgoing submission never passes through it.

The correct move is to do what the desktop client does: after sending, APPEND a copy to the Sent folder over IMAP.

Step 1 — get the raw MIME of the message you just sent

You want to store exactly what went out — same headers, same body, same attachments. Laravel's Mail::...->send() returns a SentMessage, and you can pull the full RFC 822 string out of it:

$sent = Mail::to($lead->email)->send($mailable);

$raw = $sent
    ?->getSymfonySentMessage()
    ?->getOriginalMessage()
    ?->toString();

$raw is now the complete message (From:, To:, Subject:, MIME parts, attachments — everything). Under Mail::fake() it's null, so guard for that.

Step 2 — APPEND it to the Sent folder

APPEND uploads a full message into a mailbox. The command looks like this:

a1 LOGIN "user@example.com" "password"
a2 APPEND "Sent" (\Seen) {SIZE}
<the raw message bytes>
a3 LOGOUT

That {SIZE} is an IMAP literal, and it is the one thing everybody gets wrong.

{SIZE} is the length of the message in octets (bytes), not characters.

If your message contains any multi-byte UTF-8 (an accented subject, an emoji, a name like José), PHP's strlen() is correct because it counts bytes — but mb_strlen() is not. Get this wrong and the server either truncates the message or hangs waiting for bytes that never come.

Here's a dependency-free appender over a raw TLS socket:

final class ImapSentAppender
{
    public function __construct(
        private string $host,
        private int $port,        // 993 for implicit TLS
        private string $user,
        private string $pass,
        private string $folder = 'Sent',
    ) {}

    public static function appendCommand(string $folder, string $raw): string
    {
        $folder = str_replace(['\\', '"'], ['\\\\', '\\"'], $folder);

        // strlen() = bytes, exactly what IMAP wants. Never mb_strlen().
        return 'APPEND "' . $folder . '" (\\Seen) {' . strlen($raw) . '}';
    }

    public function append(string $raw): void
    {
        // Normalise to CRLF line endings — IMAP is strict about this.
        $raw = str_replace("\n", "\r\n", str_replace("\r\n", "\n", $raw));

        $ctx = stream_context_create(['ssl' => [
            'verify_peer' => false, 'verify_peer_name' => false, // self-signed Dovecot? use a real cert in prod
        ]]);
        $fp = stream_socket_client(
            "ssl://{$this->host}:{$this->port}", $errno, $errstr, 10,
            STREAM_CLIENT_CONNECT, $ctx
        );
        if (! $fp) {
            throw new \RuntimeException("IMAP connect failed: {$errstr}");
        }
        stream_set_timeout($fp, 10);

        try {
            $this->read($fp);                        // server greeting
            $this->cmd($fp, 'a1', sprintf('LOGIN "%s" "%s"', $this->q($this->user), $this->q($this->pass)));

            // Send the command line with the literal, wait for the "+" continuation.
            fwrite($fp, 'a2 ' . self::appendCommand($this->folder, $raw) . "\r\n");
            if (! str_starts_with(ltrim($this->read($fp)), '+')) {
                throw new \RuntimeException('Server refused APPEND');
            }

            fwrite($fp, $raw . "\r\n");               // now the message itself
            $this->until($fp, 'a2');                  // wait for "a2 OK"

            $this->cmd($fp, 'a3', 'LOGOUT', allowBye: true);
        } finally {
            fclose($fp);
        }
    }

    private function cmd($fp, string $tag, string $line, bool $allowBye = false): void
    {
        fwrite($fp, "{$tag} {$line}\r\n");
        $this->until($fp, $tag, $allowBye);
    }

    private function until($fp, string $tag, bool $allowBye = false): void
    {
        while (($l = fgets($fp)) !== false) {
            if (str_starts_with($l, "{$tag} OK")) return;
            if ($allowBye && str_starts_with($l, '* BYE')) return;
            if (str_starts_with($l, "{$tag} NO") || str_starts_with($l, "{$tag} BAD")) {
                throw new \RuntimeException('IMAP error: ' . trim($l));
            }
        }
        throw new \RuntimeException("No tagged response for {$tag}");
    }

    private function read($fp): string { return (string) fgets($fp); }
    private function q(string $v): string { return str_replace(['\\', '"'], ['\\\\', '\\"'], $v); }
}

Wiring it into a send:

$sent = Mail::to($lead->email)->send($mailable);

$raw = $sent?->getSymfonySentMessage()?->getOriginalMessage()?->toString();

if ($raw !== null) {
    try {
        app(ImapSentAppender::class)->append($raw);
    } catch (\Throwable $e) {
        // Best-effort: the mail already went out. A missing Sent copy
        // must never turn a successful send into a failure.
        report($e);
    }
}

Two things that will save you an afternoon

1. It's best-effort. The email is already delivered by the time you APPEND. If IMAP is down, log it and move on — never let the copy step throw and make your controller report a failed send. Hide it behind an interface with a no-op implementation, so environments without IMAP configured just skip it:

interface SentMailboxAppender { public function append(string $raw): void; }

final class NullSentMailboxAppender implements SentMailboxAppender {
    public function append(string $raw): void { /* no-op */ }
}

Bind the real one only when the IMAP host is configured; otherwise bind the null one. Sending keeps working everywhere; the Sent copy is a bonus, not a dependency.

2. CRLF line endings. IMAP wants \r\n. Normalise before you measure the byte length, or your {SIZE} won't match what you actually send.

That's it

No ext-imap, no library — just a socket and three commands. I ran into this building the outreach flow for seoautohub.com (a Laravel app that emails PDF reports from the admin panel): messages were going out fine, but nothing showed in the team's webmail Sent folder. One APPEND after each send and every sent message now lives where you'd expect it.

If you're on ext-imap, imap_append() does the same thing in one call — but it's deprecated in PHP 8.4 and being unbundled, so a tiny socket helper like this is a decent thing to own.

Happy shipping. 📨

Is your site ready to be cited by AI? A practical intro to GEO (Generative Engine Optimization)

Marco Caciotti — Thu, 16 Jul 2026 23:02:11 +0000

More and more people search on ChatGPT, Perplexity and Gemini. Being found is no longer enough — you need to be cited.

For twenty years SEO had one clear goal: rank in Google's top results. Something deeper is changing now. A growing share of people, before buying or choosing a supplier, no longer open Google — they ask ChatGPT, Perplexity or Gemini. And to answer, these models cite some sources and ignore others.

So the question for anyone with a website becomes different: is my site among the sources AI can read and cite? That's what GEO — Generative Engine Optimization — is about.

The good news: GEO isn't magic. It rests on concrete, verifiable signals.

1. Can AI crawlers reach your site?

ChatGPT, Claude and Perplexity use dedicated crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended). If your robots.txt blocks them — often by mistake or an old setting — AI can't read you, so it can't cite you. That's the first thing to check.

2. Do you have an llms.txt file?

It's a simple file, modeled on robots.txt, that tells AI which content is most relevant to read. Still uncommon, but becoming a standard: adopting it now is an early-mover advantage.

3. Is your content "extractable"?

AI reuses structured content better: a single clear H1, subheadings, lists, direct answers, structured data (JSON-LD). A wall of undifferentiated text is hard to cite; a well-isolated answer isn't.

4. The technical basics

HTTPS, descriptive title and meta description, indexable pages. Nothing new versus classic SEO, but still prerequisites.

Where to start

The fastest way to know where you stand is to measure. We published a free audit that checks these signals in seconds and returns an "AI-readiness" score, no signup to see the result: https://seoautohub.com/audit-geo

SEO isn't dying, it's widening: beyond ranking on Google, being readable and citable by generative engines now matters. Those who move now — while the standard is still immature — gain an edge that will be far more expensive to win a year from now.

DEV Community: Marco Caciotti