Email Header Folding Mistakes in PHP

Why do email headers fold incorrectly in PHP mail functions?

You send an email using PHP’s mail() function, and it either vanishes into the void or lands in spam. You check the code — everything looks fine. But behind the scenes, a silent formatting flaw is breaking the message before it ever leaves your server.

Email headers must follow strict formatting rules: they’re not just text. They’re structured data governed by RFC 5322. When line breaks or whitespace are inserted incorrectly — especially in header values — servers misparse the entire message. PHP’s mail() function doesn’t validate this at all. You’re building a message, but it’s a house of cards.

Most developers don’t realize it, but the problem isn’t in the client or the mail server — it’s in how PHP handles header folding. When a header spans multiple lines without proper continuation syntax, it collapses. That’s not a bug. It’s a design oversight that leads to deliverability failure.

Key takeaways

PHP’s mail() function does not validate header formatting, making header folding errors common and hard to debug.
Improper line breaks or whitespace in email headers cause parsing failures, leading to undeliverable messages or spam filtering.
Correct header folding requires strict compliance with RFC 5322, using CRLF and proper continuation lines after 78 characters.

What exactly is email header folding and why does it matter?

When a single email header line in PHP exceeds 78 characters, it must be broken across multiple lines using a space or tab after the break—this is header folding. If the continuation isn’t properly indented, mail servers reject the message or flag it as spam. Proper folding ensures headers remain valid, readable, and trusted by receiving systems.

The mechanics of correct header folding

Mail servers follow strict standards, defined in RFC 5322, that require long header lines to break at 78 characters maximum. After the break, the next line must start with exactly one space or tab—no more, no less. This formatting tells the server the line is a continuation, not a new header.

Let’s say you’re sending a MIME content-type header that runs long. Instead of this:

Content-Type: multipart/mixed; boundary="----=_NextPart_000_0001_01C7C24D.01C7C24D"

You must fold it like this:

Content-Type: multipart/mixed; boundary="----=_NextPart_000_0001_01C7C24D.
01C7C24D"

Notice the single space after the line break. If you use a double space, a tab, or nothing at all, the header is malformed.

Why malformed headers hurt deliverability

Incorrect folding can break parsing. The receiving server may reject the message outright, treat it as spam, or strip critical metadata. This leads to bouncebacks, poor inbox placement, and damage to your sender reputation.

Even a single misfolded header can trigger filtering rules. According to industry standards and practices outlined in RFC 5322, header parsing isn’t forgiving. Servers assume malformed input comes from untrusted sources.

Many developers assume PHP’s mail() function handles this automatically, but it does not. The responsibility is yours to ensure each header line—especially in complex messages—adheres to the 78-character limit and uses correct continuation formatting.

Testing your email headers before sending is a low-effort, high-impact step. You can validate your header structure using tools like MailTester’s inbox placement tests, which check how real inbox providers handle your messages. Catching folding errors early prevents delivery failures and protects your sender reputation.

How PHP mail() function can inadvertently cause header folding issues

You can accidentally trigger email header folding errors in PHP's mail() function by including long or unescaped values in headers like To:, Subject:, or CC: without enforcing line breaks at 78 characters. The function doesn’t validate formatting or sanitize input—so when strings exceed the line length limit, they may be split mid-word or mid-character, corrupting the header structure. This breaks parsing in some mail servers and can lead to rejected mail or deliverability issues.

Why manual header formatting in PHP is risky

When you build headers manually—say, using concatenation like $headers = "To: " . $email . "\nSubject: " . $subject;—you’re bypassing any built-in validation. Long subject lines, complex names with commas, or special characters like =?UTF-8?Q?G=C3=B6ttigen?= can cause unexpected folding if not properly handled. The RFC 5322 standard specifies that lines should be no longer than 78 characters, and any line exceeding that must be folded using a soft line break (a space or tab after a newline).

PHP’s mail() function doesn’t do this for you. It simply passes the string as-is. If you’re using a user-supplied subject like "Newsletter for Q3 2024: Performance Reports and Upcoming Feature Launch", it may not split correctly at 78 characters. This results in a malformed header, which some mail servers interpret as a security risk or misformatting, triggering spam filters or outright rejection.

How to prevent it in practice

Let’s be real: unless you’re already using a library like PHPMailer, you're likely to get this wrong. The safest path is to avoid raw mail() calls entirely, but if you’re stuck with it, enforce line limits and use proper RFC 5322 folding rules. A function like wordwrap() can help, but only on the body or individual header fields—never assume it works on full headers.

The industry-standard approach is to use a dedicated library. Libraries like PHPMailer or SwiftMailer handle header folding automatically and include validation for common pitfalls. They follow RFC 5322 exactly, ensuring headers remain readable and deliverable across clients.

Still, even if you fix your code, you can’t know for sure if an email will land in the inbox until you test it. Testing with real inboxes—using tools designed for that—lets you catch failures before they hit customers. This is where inbox placement testing, like the service available at MailTester’s inbox tester, comes in. You can verify whether your headers, formatting, and content behave reliably across real email clients and providers.

Common PHP header folding mistakes you must avoid

When sending emails via PHP’s mail() function, header folding errors break compliance with RFC 5322, causing rejection or misdelivery. You must ensure every line break in a header is followed by exactly one space or tab, and never insert breaks inside quoted strings or long values without escaping. These oversights are common in dynamic systems and lead to invalid headers, especially with variable subject lines or recipient lists.

Header formatting pitfalls to fix today

Break header lines only with a single space or tab after the newline—never a bare line break. The standard requires a whitespace character (space or tab) to indicate continuation; omitting it breaks the header structure.
Avoid using multiple spaces or tabs as continuation indicators. Use exactly one space or one tab after a line break. Multiple whitespace characters can confuse mail servers and cause parsing issues.
Never insert line breaks inside quoted strings like email addresses (e.g. "[email protected]"). If you must wrap such data, quote the full string and apply folding only outside it, never within. Breaking a quoted string corrupts the address and triggers rejection.
Always check the length of dynamic header values (like subjects or recipient lists) before building headers. Long fields—especially in templates—can exceed the 78-character limit per line and break unless properly folded.

How to catch and fix these in practice

Let’s be honest: even seasoned developers slip up on header folding. The error isn’t always apparent in logs—many servers silently fail to parse malformed headers. You can verify your output before sending by examining raw headers, such as with tools like MXToolbox or by using inbox placement testing to see how your message renders across real mail providers.

Consider using a proper email library like PHPMailer or SwiftMailer instead of relying on PHP’s mail() function—it enforces correct header formatting. But if you must use mail(), sanitize inputs, validate lengths, and never let dynamic data bypass folding rules.

How to manually fix and validate header folding

You can fix email header folding in PHP by ensuring each line stays under 78 characters, splitting only at word boundaries, and adding a single space after line breaks. Always validate the output using tools like MxToolbox or an RFC 5322 validator to catch syntax errors before sending.

Follow the RFC 5322 standard

Headers must not exceed 78 characters per line. This rule exists to ensure compatibility across mail servers and clients, many of which were designed around older systems with strict line limits. Violating this standard risks delivery failures or misinterpretation.

Check your header length before sending. For example, a Subject or From header longer than 78 characters must be folded. Use RFC 5322 Section 3.1.1 as your reference for line-length limits and folding rules.
Split at word boundaries, not in the middle of a word. If a header like Content-Type: application/json; charset=utf-8 exceeds 78 characters, break it only after a space or punctuation—never mid-word. This maintains readability for mail clients and prevents parsing errors.
Use a single space at the start of continued lines. After a line break, add exactly one space (not two or more) to signal continuation. For example: Subject: Long subject line with multiple words that need folding becomes:
Subject: Long subject line with multiple words that need folding.
Log the final header string before sending. Print the raw output to verify folding behavior in your environment. This helps spot edge cases like nested headers, encoding issues, or missing spaces.
Validate the output with a tool like MxToolbox’s Email Header Validator. Paste the full header block and check for syntax violations. It will flag incorrect line folding, extra spaces, or improper continuation characters.

Pro tip: Test real-world delivery

No amount of local testing beats sending a real test email to a known inbox. Use tools like MailTester’s inbox placement tester to evaluate how your properly folded headers perform across major inboxes. Some filtering systems penalize malformed headers even if they’re technically valid.

For bulk list maintenance, verify your sender infrastructure with bulk email list verification—it helps catch invalid or risky addresses before they hit your sending pipeline. Clean lists improve deliverability and sender reputation, which complements proper header formatting.

Proper header folding example: a correctly formatted PHP mail header

When sending emails via PHP’s mail() function, improper header folding can cause rejection by mail servers. Long headers—especially Subject lines—must be broken at 78 characters using a soft line break (CRLF followed by a space). Here’s how to format it correctly: line breaks after 78 characters, not mid-word, with a space after the line break. This avoids protocol errors and ensures deliverability.

Why header folding matters

Mail servers expect headers to follow RFC 5322, which defines strict formatting rules. If your Subject line is too long and isn’t folded properly, some MTAs (Mail Transfer Agents) will reject it outright. This often looks like a silent failure—no bounce, just a vanished message. It’s especially common when sending transactional emails programmatically.

Let’s walk through a correctly folded header example using real PHP mail() syntax. The critical part is breaking lines only after 78 characters, always with a space after the CRLF. The headers you’re using—Subject, To, From, Date, MIME-Version, Content-Type—must be on separate lines and properly formatted.

Example: Correctly folded PHP mail headers

Subject: This is a very long subject line that needs to be folded properly to avoid rejection
To: [email protected], [email protected]
From: [email protected]
Date: Mon, 1 Jan 2026 08:00:00 +0000
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8

Here’s how to fold the long Subject line correctly:

Subject: This is a very long subject line that needs to be folded
properly to avoid rejection

This ensures the line does not exceed 78 characters (including the space after the CRLF) and maintains readability to the MTA. The rule applies to any header field that exceeds the limit—especially when you’re building dynamic emails in PHP.

You can test how well your email headers pass common server checks using a tool like MailTester’s inbox placement tester. It simulates real-world delivery conditions and checks for issues including invalid header formatting and folding errors.

For reference, the official definition is in RFC 5322, section 3.2.4, which specifies line length limits and folding rules. Following it avoids common failures like message rejection or spam filtering. The standard is clear: fold longer headers with a line break and space, not mid-word or too late.

How to detect folding issues before sending via real email testing

You can catch header folding mistakes in PHP mail functions by testing email delivery in real inboxes using MailTester’s inbox-placement tool. It simulates how real mail servers process your headers, flagging malformed or non-compliant formatting before you send to actual users. This catches issues that automated validators might miss.

Simulate real-world delivery with inbox-placement testing

Instead of relying solely on syntax checks, run your email through MailTester’s inbox-placement test. It sends your message to real domains like Gmail, Yahoo, and Outlook, where headers are processed exactly as they would be in production. If your headers are folded incorrectly, these systems may reject or alter the message—this test reveals that behavior.

After sending, you’ll see deliverability results that show whether the email was accepted, rejected, or quarantined. A rejection due to malformed headers is a red flag. The test logs the exact point of failure, so you can trace it back to the folding issue in your header line lengths, whitespace, or structure.

Verify headers in isolation with the real-time API

When testing a single email, use MailTester’s real-time verification API to send a sample message with known good formatting. This API lets you test individual headers or full email structures without sending to real users.

Send your email as a complete message with test content and check the response. You’ll get back details on header compliance, including whether lines exceed the 78-character limit defined in RFC 2822. If a header like Subject: or From: is broken incorrectly across lines (e.g., after a space), you’ll see a warning.

For a complete list of header requirements, refer to the official specification at RFC 2822. While it’s the standard, implementation varies — that’s why real-world testing is essential. Tools that only check syntax can’t confirm whether a header will trigger spam filters or be silently rejected.

Let’s say your PHP script generates headers using wordwrap() or manually injects line breaks. Even small errors—like a missing space after a = in a Content-Transfer-Encoding line—can cause the server to drop the message. Testing with a real inbox simulator catches these edge cases reliably.

To test your email list before sending, use bulk email verification at MailTester’s email list verification tool to clean up invalid or malformed addresses early.

How to test your email headers for folding compliance

You can test your email headers for folding compliance by sending a real email to MailTester’s verification endpoint with your exact header structure. The service will parse your headers and flag any folding errors that could cause delivery issues. Use the in-app AI assistant to ask: “Is this header folding correct?” and get a technical breakdown of line breaks, continuation spacing, and RFC 5322 compliance.

Step-by-step verification process

Send a test email with your header structure to MailTester's verification endpoint. Use a real email address you control, ensuring your headers (From, To, Subject, etc.) are identical to what your PHP mail() function generates. This tests your exact output, not a hypothetical.
Check the deliverability feedback in the results. MailTester returns detailed parsing logs. Look for warnings like “Header folding not compliant” or “Continuation line lacks single space.” These errors arise when a header line exceeds 78 characters and isn’t split correctly with a space after the line break.
Use the in-app AI assistant to validate folding correctness. Type: “Is this header folding correct?” and include the header text. The AI will reference RFC 5322 and check line length, continuation spacing, and insertion points. It flags issues like missing spaces after line breaks or improper wrapping.
Verify no delivery or parsing errors are reported. If the AI flags non-compliance, revisit your PHP code. Common issues include manual line breaks without proper spacing or hard-coding header lengths without dynamic wrapping. Re-send after fixing.

Why compliance matters

Incorrect header folding can break parsing in older mail servers or cause emails to be rejected. The RFC 5322 standard explicitly requires that long header values be split with a single space after the carriage return. Missing this space is a common mistake in hand-written PHP mail() calls.

MailTester checks all standard headers—From, To, Subject, Cc, Bcc, Content-Type, and custom headers—for RFC 5322 conformance. It’s not enough to have valid syntax; the folding must follow precise formatting rules.

Best practices to prevent header folding issues in PHP

You must wrap long header values manually using a function that respects RFC 5322’s 78-character line limit, or you risk broken headers and rejected messages. Use wordwrap() with a maximum width of 76 characters for each line, and always validate headers before passing them to mail(). Don’t rely on PHP’s built-in function to auto-format—verify your output with tools that check syntax and deliverability.

Use proper line breaking for header values

Never let header values span more than 76 characters per line. The RFC 5322 standard limits line length to 78, but you must account for the line break itself.
Wrap long header strings using custom functions or wordwrap() with a width of 76, ensuring each continuation line starts with a space or tab to maintain proper folding.
Validate all header strings before they’re passed to mail()—even small format errors can trigger rejection by receiving servers.
Use RFC 5322 as a reference for header formatting rules, especially line length and folding syntax.

Prevent issues before sending

Integrate a real-time email verification API to catch malformed headers or invalid addresses before they go out.
Use MailTester’s real-time API to validate header content and address hygiene in bulk or on-demand.
Run inbox placement tests with MailTester’s inbox tester to see how your messages appear across major providers—folding issues often cause visible corruption in mail clients.
For large email lists, apply bulk verification to identify and clean up problematic entries before sending.

Let’s be clear: the mail() function doesn’t fix your formatting. It just passes your code along. If your headers aren’t well-formed, deliverability drops. The best defense is early validation—before your message even leaves your server.

Why header folding is just one part of deliverability health

Even if your PHP mail headers are folded correctly, your messages can still land in spam or fail outright. A clean header structure means nothing if the sender domain has a poor reputation, lacks proper SPF or DKIM alignment, or is on a blocklist. Deliverability depends on multiple layers — header correctness is just one of them.

Reputation and authentication are non-negotiable

Spam filters don’t just look at headers — they inspect the sender’s history, domain records, and behavioral signals. A domain with a weak reputation or missing authentication (SPF, DKIM, DMARC) will get filtered even with technically perfect headers. The email might be formatted flawlessly, but ISPs still reject it based on trust signals.

Let’s be clear: header folding fixes one small technical problem. It doesn’t compensate for poor sender reputation or misconfigured DNS records. Even a single misaligned DKIM signature can break authentication, causing messages to fail silently or get marked as spam.

Malformed data can trigger filters regardless of domain score

A single malformed header — even one with a non-folding line longer than 78 characters — can trigger spam filters. These filters scan for anomalies and inconsistencies, and a violation in any field can raise suspicion. This is why tools that check for standard compliance (like RFC 5322) are essential.

But no amount of header validation will fix a sender with a history of blacklisting, high bounce rates, or user complaints. You need to verify both the technical setup and the underlying reputation.

That’s where MailTester helps. It checks not just for folding accuracy, but also validates SPF, DKIM, and DMARC alignment, and assesses overall domain health. It can also test inbox placement across major providers — a real-world check no static header validator can provide.

Use MailTester’s bulk verification to catch issues in large lists, or test individual addresses with their email checker. It also offers a real-time verification API for integration into automated workflows.

Deliverability isn’t just about format. It’s about trust, consistency, and proven sender behavior. Header folding is a technical detail — but your domain’s health, authentication, and real-world inbox placement are what actually matter.

Fix header folding now—test your emails before they go live

Header folding errors are silent failures. They don’t trigger errors, but they break delivery, trigger spam filters, and hurt inbox placement without clear warnings.

Real-world testing with MailTester’s inbox-placement feature exposes these issues before your emails reach inboxes. It simulates actual mail server behavior, catching technical flaws like incorrect header formatting.

With 98.9% accuracy and credits that never expire, MailTester gives you reliable verification for every email you send. Catching header folding mistakes early prevents deliverability loss and protects sender reputation.

Sources

Benchmark testing of 15 major email service providers found about 10.5% of legitimate emails land in the spam folder and a further 6.4% go undelivered. — EmailTooltester deliverability benchmark (via WarmForge) (2026)

Keep reading

Ready to put this into practice? MailTester verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

What happens when email headers are folded incorrectly?

Incorrect header folding can cause the mail server to reject the message, treat it as spam, or fail to deliver. The recipient may not receive the email at all.

Does PHP mail() automatically handle header folding?

No. PHP's mail() function does not enforce or validate header formatting. Developers must manually ensure compliance with RFC 5322 rules.

How long can an email header line be?

Headers should not exceed 78 characters per line. If longer, they must be folded with a leading space at the start of the continuation line.

Can header folding errors be detected by most email services?

Yes, most mail providers and spam filters check for valid header syntax. Malformed headers increase spam likelihood and can block delivery.

Why should I test headers with a service like MailTester?

MailTester’s inbox-placement testing simulates real delivery conditions and can detect syntax issues like incorrect folding before your emails reach users.

Is there a built-in way to validate headers in PHP?

No native PHP function validates email header syntax. You must implement custom checking or use a third-party tool like MailTester.

Do header folding issues affect only certain email providers?

No. All major email providers, including Gmail, Outlook, and Yahoo, enforce strict header parsing standards. All are affected by folding errors.

How do header issues impact sender reputation?

Repeatedly sending emails with malformed headers can lower sender reputation due to increased spam scoring and delivery failures.

Can disposable emails be detected in PHP mail() functions?

Not directly. Use MailTester’s API to verify addresses for disposable domain status before sending.

How many free verifications does MailTester offer?

100 free verifications to start—no expiration on purchased credits, and 98.9% accuracy for email validation.

How does MailTester detect header issues?

MailTester analyzes message structure, header syntax, and deliverability signals during inbox placement testing.

Can MailTester test bulk email campaigns?

Yes. Use MailTester’s bulk list verification to clean your email list and test header formatting at scale.