Check email subject line length
“Your order ships tomorrow morning” has 33 characters, so it fits both the 40-character mobile preview and the 70-character desktop one. For longer subjects you see where the cut falls and the slice that stays visible. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Subject
- Your order ships tomorrow morning
- Char count
- 33
- Mobile limit
- 40
- Desktop limit
- 70
- Chars over mobile
- 0
This email subject length checker measures your subject line in Unicode code points and compares it to fixed mobile and desktop inbox preview limits used by popular mail clients. Subjects that look perfect in a wide browser window often clip on a phone lock screen or in the Gmail app, hiding the offer, deadline, or brand cue that was meant to drive the open. Marketers, support teams, product managers, and developers paste a draft subject, see the character count, learn whether it would be truncated on mobile or desktop, and read the exact preview slice the recipient would see. The engine is fully deterministic: one code-point count, fixed limits of forty characters for mobile and seventy for desktop, pure string slices, and no network.
What mobile and desktop subject truncation means
Inbox clients do not always show the full subject line. On many phones the preview area is narrow, so strings longer than about forty characters are clipped with an ellipsis and the rest never appears until the message is opened. Desktop and webmail panes are wider, often near sixty to seventy characters, but still not infinite.
Campaign teams that only check length in a spreadsheet cell or a full-width editor miss the cut that happens on a lock screen. This checker answers a practical send-time question: given this exact subject, would it be truncated on a typical mobile preview, a typical desktop preview, or neither. It counts Unicode code points so emoji and non-Latin scripts are measured more fairly than a raw UTF-16 length that splits surrogate pairs.
There is no language model rewriting your copy, no A/B generation of alternate subjects, and no network call to a mailbox provider. If you need creative subject variants, use a subject-line generator; if you need a full word and character counter for body copy, use a word-count tool.
Where subject length checks fit in marketing, support, and software
Lifecycle and acquisition teams meet subject length when a Black Friday line that looked fine on a laptop loses the discount code on mobile, when a transactional receipt subject buries the order number past the fold, or when a newsletter teaser is cut mid-phrase. Support and success teams use the same check for ticket-notification subjects so customers see the case id or product name in the notification shade.
Classroom and bootcamp exercises use the tool as a deterministic string exercise: count code points, compare to fixed limits, and emit a status without calling a mailbox. Agencies paste client drafts into the free browser form during reviews, then lock the same limits into CI so freelancers cannot ship a seventy-character mobile subject that only fits desktop. Pair it with subject-line generators, email formalizers, word counters, or phishing detectors when you are building a small lab of free, deterministic email utilities for forms, CMS prep, and send hygiene.
What you can do with it
Campaign send-time mobile gate
Paste draft subjects before a blast and flag any line that exceeds the forty-character mobile preview so offers stay visible on phones.
Transactional subject review
Check receipt, shipping, and password-reset subjects so order numbers and action words are not clipped on mobile or desktop.
FAQ
What does the email subject length check cost?
It is free in your browser on this page.
What are the mobile and desktop character limits?
This tool uses fixed industry-style limits of 40 characters for mobile previews and 70 for desktop previews, counted as Unicode code points.
What happens if the subject is empty?
Provide a non-empty subject line; whitespace-only paste is treated as empty.
Do emoji count as one character in a subject line?
The checker counts Unicode code points, so an emoji is not split into two units the way some counters do. Non-Latin scripts are measured the same way, which keeps the count closer to what an inbox shows.
Can I see how my subject will look when it is cut off?
Yes. Along with the count, you get the exact slice shown in a mobile and a desktop preview, plus how many characters spill past each limit, so you can move the offer or deadline to the front.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/write/email-subject-length-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"subject":"Your order ships tomorrow morning"}'const res = await fetch("https://api.kit.forhosting.com/write/email-subject-length-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"subject": "Your order ships tomorrow morning"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/write/email-subject-length-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"subject": "Your order ships tomorrow morning"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/write/email-subject-length-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"subject":"Your order ships tomorrow morning"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"subject":"Your order ships tomorrow morning"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/write/email-subject-length-check", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"subject": "Your order ships tomorrow morning"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "write.email_subject_length_check",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_chars | 500 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Empty or whitespace-only subjects are rejected with invalid_input so a blank form cannot become a silent success. Use it free in the browser while writing campaigns, or call the API at $0.002 per successful request when you need reproducible truncation flags in CI, ESP previews, or content pipelines.
What mobile and desktop subject truncation means
The response echoes the subject, reports char_count, repeats the fixed mobile_limit of forty and desktop_limit of seventy, sets truncated_mobile and truncated_desktop booleans, reports how many characters spill past each limit, and returns preview_mobile and preview_desktop as the visible slices. Status is ok when the subject fits both limits, truncated_mobile when it exceeds only the mobile limit, and truncated_desktop when it exceeds the desktop limit as well. The engine either builds an exact length report inside the supported maximum length or rejects the request with invalid_input. Rejected cases include a missing subject field, a null value, an empty string, whitespace-only paste, objects and arrays that are not plain text, and payloads longer than the documented maximum.
How the subject field is read and how limits stay reproducible
The value must be a non-empty string after a meaningful content check; finite numbers and bigints are stringified first so a bare order identifier typed as a number still produces a stable digit subject. Outer spaces that sit around real words still count toward length because inboxes display them; only pure whitespace with no visible content is treated as empty. Character counting uses Array.from on the string so each Unicode code point, including many emoji, counts as one. Desktop previews follow the same rule at seventy. Status never depends on the current date, locale collation tables that reorder letters differently across hosts, or random sampling. The preferred field name is subject, but aliases text, input, title, line, and s are accepted so query strings, spreadsheets, ESP export columns, and typed forms can reuse the same contract without renaming columns. Booleans, plain objects, and arrays are rejected with a clear message so a mistaken JSON body does not become the word true or an unhelpful object dump. Empty string and whitespace-only paste are always invalid_input: the product promise is check a real subject line, not invent a zero success for a blank submit. Length is capped at five hundred characters so a runaway paste cannot monopolize a Worker; longer payloads fail with an explicit limit message rather than a truncated silent cut. Truncation previews slice with the same code-point boundary: when truncated_mobile is true, preview_mobile is the first forty code points; when false, it is the full subject. Pair the free browser run on this page with the priced API when you need the identical report inside an automated pipeline that gates sends before they leave your ESP.
Where subject length checks fit in marketing, support, and software
On this page the work runs entirely in your browser; through the API each successful analysis costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a campaign desk demo to an automated gate without changing the numeric result.
Integration use cases
CI subject length fixtures
Assert deterministic truncated_mobile and status values in pipelines and ESP hooks without re-implementing inbox limits by hand.
Technical questions
How is character count measured?
char_count is the number of Unicode code points via Array.from(subject).length, so many emoji count as one unit rather than two UTF-16 code units.
What does status truncated_mobile mean?
The subject is longer than the mobile limit but still within the desktop limit. truncated_desktop means it exceeds the desktop limit as well.