Extract action items
Meeting notes are where decisions go to get forgotten. This endpoint reads any block of text — minutes, a chat thread, a rambling email — and pulls out only the parts that are actual commitments: who is doing what, and by when if that was said. It turns prose into a task list without anyone re-reading the transcript.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The gap between 'we discussed it' and 'someone owns it'
Most action items die quietly between a meeting ending and a task tracker getting updated, not because people are careless but because manually combing notes for commitments is tedious and easy to skip. text.extract_action_items closes that gap by treating extraction as a task in itself: send it the raw notes and it separates genuine commitments from general discussion, opinions, and context that was never meant to become a to-do.
How the endpoint reads intent
POST /text/extract-action-items looks for the linguistic markers of a commitment — imperative phrasing, 'I'll', 'can you', assigned names, dates, and follow-up language — and returns a structured list where each item includes the task text, an owner if one was named, and a deadline if one was mentioned. If the notes never assign an owner, the field is left empty rather than guessed, because a wrongly assigned task causes more confusion than an unassigned one.
Notes, transcripts, and the messiness of real conversation
Real meetings do not talk in bullet points. People restate things, interrupt each other, and bury a firm commitment inside a tangent about something else entirely. The task is built for that messiness — it works on raw transcripts and loosely structured notes, not just tidy pre-formatted lists, which is the actual condition most notes are in when someone finally gets around to processing them.
Fitting into a project workflow
Because the response is structured and consistent, teams commonly pipe it straight into a task tracker, a project board, or a follow-up email draft, closing the loop between a meeting ending and work actually starting. Running it asynchronously means a call can be transcribed, processed, and turned into assigned tasks before anyone has left the building.
What good extraction looks like
The output is not a summary of the meeting; it deliberately ignores everything that is not an actionable commitment, including decisions with no follow-up and observations that were interesting but did not require anyone to do anything. That restraint is the point — a task list that includes every sentence someone said is not a task list, it is a transcript with extra steps.
What you can do with it
Post-meeting task sync
Feed the raw meeting transcript in and push the returned items straight into a project board, with owners pre-filled wherever they were stated aloud.
Client email follow-through
Extract the commitments buried in a long client thread so account managers never miss the one line where they promised a deliverable by Friday.
Standup and retro notes
Turn daily standup notes into a running list of blockers and owed follow-ups without anyone manually re-typing them into a tracker.
Voice-memo processing
Pair with transcription to convert a rambling voice memo dictated after a call into a short, assignable list of next steps.
FAQ
How does the extract action items API tell a task apart from a general comment?
It looks for commitment language — assignments, imperatives, dates, follow-up phrasing — and only returns items that read as something someone is actually going to do.
Does it assign owners automatically if none are mentioned?
No. If the source text never names who owns a task, the owner field is left blank rather than guessed, so you never get a task wrongly attributed to the wrong person.
What text formats can I send it?
Raw meeting transcripts, chat exports, emails, or loosely structured notes all work; it is built to handle messy, real conversation rather than pre-cleaned bullet lists.
Is there a free trial for this endpoint?
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 does it cost to process a long transcript?
$0.003 per request plus $0.0135 per 1,000 words, so a 30-minute meeting transcript typically costs a few cents. Failed tasks are never billed; the system retries up to three times first.
Can I extract action items in bulk from many meetings?
Yes, queue async requests for as many transcripts as you have and collect the structured results by webhook as they finish.
How do results come back?
By signed webhook, which is best for automated pipelines, or a signed link valid for 24 hours if you want to fetch results manually.
Will it catch deadlines mentioned indirectly, like 'before we ship next week'?
It picks up dates and time references stated in the text, including relative ones, but it will not infer a deadline that was never actually said.
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/text/extract-action-items \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/extract-action-items", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/extract-action-items",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/extract-action-items", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/extract-action-items", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.extract_action_items",
"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_tokens | 20000 |
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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |