Open an EML file
An .eml file is a whole email flattened into one plain-text blob: headers, MIME boundaries, encoded bodies and attachments all mixed together by design. This endpoint parses that blob back into clean, structured fields, so an exported or forwarded email becomes usable data instead of a wall of text nobody wants to regex.
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
Why raw email is harder to read than it looks
The .eml format has been around since the early days of internet mail, built on the same RFC 822 header conventions the web still runs on, and it was designed for mail transfer agents to pass around, not for application code to read comfortably. A single exported email can contain nested MIME parts, quoted-printable or base64 encoding, multiple character sets, inline images referenced by content-ID, and attachments buried several layers deep in a multipart tree. Writing a parser that handles all of that correctly, across every mail client that ever generated a file, is a project in itself, which is exactly the work this endpoint has already done.
What the endpoint hands back
You send the raw file to POST /ocr/eml, receive a task_id immediately, and the parse runs asynchronously behind it. The result separates the message into its header fields such as sender, recipients, subject, and date, a readable body in both plain text and HTML where available, and a list of attachments with filenames, MIME types, and sizes so you can decide which ones to fetch and process further. Delivery works either way you prefer: a signed webhook fired the moment parsing finishes, or a signed link you retrieve within 24 hours.
Where .eml files actually come from
Almost nobody generates a .eml file on purpose; it shows up as the export format when someone drags an email out of a mail client, forwards a message as an attachment for a compliance review, or when a legal e-discovery tool dumps a mailbox to disk. That makes this endpoint less of a general email tool and more of a translation layer for the moment an email leaves its inbox and needs to become a record: a support ticket, a case file, an audit log entry.
How it fits into a larger pipeline
Teams typically chain this after a document intake step that accepts .eml uploads and before a classification or extraction step that treats the parsed body and attachments as regular documents. A support desk might parse an escalation email, pull its attachments, and feed each one back through document classification so a screenshot and a contract get handled differently. Because every call is stateless and billed independently, it works the same whether you are parsing a single forwarded complaint or replaying a whole mailbox export.
What it costs
Pricing is flat and simple: $0.002 per request, with no per-page or per-attachment surcharge, since parsing structure rather than performing OCR is genuinely lightweight work. A failed parse is never billed, we retry automatically up to three times before returning a specific error describing what was malformed. There is no free tier or trial; access needs prepaid balance, and calls without one return HTTP 402 rather than being queued or throttled silently.
What you can do with it
Support ticket ingestion from forwarded emails
A helpdesk parses emails forwarded by staff into a ticketing system, pulling the original sender and attachments out of the forwarded .eml.
Legal e-discovery review
A litigation support team parses a folder of exported .eml files to extract headers and attachments for privilege review at scale.
Compliance archiving
A financial firm parses flagged emails into structured records so headers and attachment lists can be indexed for retention audits.
Automated invoice capture from email
An accounts payable system parses vendor emails to isolate PDF invoice attachments before sending them into a document-to-JSON extraction step.
FAQ
What exactly does an EML parser API extract?
It separates a raw .eml file into headers like sender, recipients, subject and date, the message body in plain text and HTML, and a list of attachments with filenames, types and sizes.
Does it decode base64 and quoted-printable attachments?
Yes, decoding MIME encodings and multipart structure is exactly what the parser handles, since that is what makes raw .eml files hard to read in the first place.
Can it also fetch and process the attachments it finds?
The endpoint returns attachment metadata and content so you can route each attachment into a separate extraction or classification step as needed.
Is there a free trial for the EML parser?
The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.
How much does it cost to parse an email file?
It is a flat $0.002 per request regardless of email size or attachment count, and you are not charged for a failed parse.
Does it work with .msg files from Outlook too?
This endpoint is built specifically for the .eml format; if your source is .msg, export or convert to .eml before sending it here.
How fast do I get the parsed result?
You get a task_id immediately, and the parsed result arrives by signed webhook when ready or through a signed link valid for 24 hours.
Can I parse a large batch of exported emails at once?
Yes, each request is independent and billed per email, so a single forwarded message or a mailbox export of thousands of files works the same way.
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, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/ocr/eml \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/ocr/eml", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ocr/eml",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/eml", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/eml", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"input": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ocr.eml",
"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_mb | 25 |
max_pages | 10 |
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. |