Turn an email into a webhook
POST /notify/email-in takes an email your system receives — from a customer reply, a support address, a forwarded document — and turns it into structured data delivered to your own webhook, attachments included. It's for the direction of email that's usually ignored: not what you send out, but what lands in your inbox and needs to become part of your application.
Outbound email gets all the attention; inbound is the harder half
Nearly every notification system is built to send mail; almost none of them are built to receive it and do something useful with what comes back. A customer replies to a support ticket, someone forwards a receipt to an expense address, a vendor emails a purchase order as a PDF — that inbound traffic usually just sits in a mailbox, read by a human who then re-types it into a system by hand. This endpoint exists specifically to close that loop.
How an email becomes a webhook call
An address you configure routes incoming mail into the parsing pipeline; the message is broken down into sender, subject, body and any attachments, and delivered to your application as a webhook call carrying that structured data, with attachments included rather than left behind as links you have to chase down separately. The processing itself is asynchronous — a task_id tracks the job, and you can also retrieve the result via a signed link valid for 24 hours if the webhook delivery needs a fallback.
Where inbound parsing sits in the history of email automation
Reading mail programmatically is as old as mail servers themselves — early systems parsed inbox contents with brittle regular expressions tied to a specific mail format. What's different now is the diversity: attachments, multipart MIME, inline images, forwarded threads with quoted history. A parsing endpoint has to handle all of that consistently, which is exactly the tedious, high-maintenance work this call takes off your hands.
What arrives on the other end
Your webhook receives the sender address, the subject line, the plain-text and HTML bodies where available, and each attachment in a form your application can store or process directly — an uploaded PDF, an image, a spreadsheet someone forwarded. There's no polling a mailbox and no IMAP connection to maintain; the moment mail arrives, your endpoint is called.
Why this belongs in an automated stack
Turning email into a webhook call means inbound mail can trigger the same downstream logic as any other event source in your system — creating a support ticket, filing an expense, attaching a document to a record — without a person acting as the manual bridge. A failed delivery to your webhook is retried automatically up to three times, and nothing is charged for an attempt that never completes.
What you can do with it
Support ticket replies by email
A customer replies directly to a ticket notification, and the reply becomes a webhook call that appends their message to the ticket automatically.
Forwarded receipts and invoices
An employee forwards a receipt to an expenses address, and the PDF attachment lands in your expense system without anyone re-typing the amount.
Vendor purchase orders by email
A supplier emails a PO as an attachment, and it's parsed into your order system the moment it arrives instead of waiting for someone to open their inbox.
Lightweight form submissions via email
A simple 'reply to this address to confirm' flow captures the reply's content as structured data without building a web form for it.
FAQ
How does an email get routed to the API?
You configure an inbound address that routes to the parsing pipeline; mail sent there is parsed and delivered to your webhook as structured data automatically.
Are attachments included in the webhook payload?
Yes — attachments are delivered along with the rest of the parsed message rather than left behind, so a forwarded PDF or image arrives ready to store or process.
What does inbound parsing cost?
$0.002 per request plus $0.0035 per email processed, the same structure as our outbound sends.
Is there a free tier to test inbound parsing?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
What if my webhook endpoint is briefly down?
Delivery to your webhook is retried automatically up to three times before a clear error is raised, and a failed task is never charged.
Can I get the parsed result without a webhook?
Yes, a signed link valid for 24 hours is also available as a fallback if you'd rather retrieve the result than receive it pushed.
Does it handle multipart and HTML emails?
Yes, the parsing pipeline breaks down plain-text and HTML bodies along with attachments regardless of how the original message was composed.
Can I use this for something other than support replies?
Yes — any workflow where email is the easiest input channel for a human, from forwarded invoices to vendor orders, can be turned into structured data this 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/notify/email-in \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/notify/email-in", {
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/notify/email-in",
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/notify/email-in", 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/notify/email-in", 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": "notify.email_in",
"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.
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. |