Extraktr Documentation

Introduction

Extraktr turns messy conversations into structured, actionable output. Paste a Slack thread, Gmail chain, Discord discussion, or any raw text — and get back clear tasks, decisions, risks, and a summary in seconds.

How it works

Extraktr's extraction engine reads your conversation, identifies who said what, and classifies each statement into structured categories. The output is a JSON object you can copy, export, or share via link.

• Paste — drop raw conversation text into the input panel
• Extract — the engine processes and classifies every line
• Act — review tasks, decisions, and risks in structured output

Built for

Teams and individuals who process conversations daily — project managers tracking action items, engineering leads capturing decisions, anyone who needs to stop re-reading threads.

Quick Start

Get structured output in under a minute. No account required for the free tier.

1. Paste a conversation

Go to extraktr.com/extract and paste your conversation into the input panel. One message per line, with a speaker label followed by the message.

Chris: Move the release to Friday?
Morgan: Yes, let's do Friday.
Chris: Friday it is. I'll send the calendar invite.
Jordan: I can own the release notes — will have a draft by Thursday.
Morgan: We decided to skip the beta for this one.
Alex: One risk: if the API change isn't merged by Wednesday we might slip.

2. Run extraction & review

Click Run Extraction. The pipeline processes your input and displays structured results in the output panel — organized by Tasks, Decisions, Risks, and Summary tabs.

Input Formats

Extraktr accepts raw conversation text from any source. Each line should have a speaker label (name, email, or handle) followed by their message.

• Slack — paste thread content directly
• Gmail — copy email chain body text
• Discord — copy channel or thread messages
• Microsoft Teams — paste chat or meeting transcript
• Generic — any "Name: message" format

Auto-detect

The source type selector defaults to Auto, which detects the format automatically. You can override it manually if auto-detect misclassifies your input.

Understanding Output

Every extraction produces four categories of structured data. Each item includes the extracted text and, where available, the source reference linking back to the original conversation line.

Tasks

Action items identified in the conversation. Each task can include text, an assigned owner, a deadline, and a source reference pointing back to the original message.

Decisions

Agreements, conclusions, or choices made during the conversation. Decisions include the decision text and optional source and confidence indicators.

Risks

Potential blockers, concerns, or uncertainties flagged in the conversation. Risks are surfaced so they don't get buried in long threads.

Summary

A concise overview of the entire conversation — the key points distilled into 1–3 sentences.

{
  "summary": "Team agreed to move release to Friday...",
  "tasks": [
    { "text": "Send the calendar invite", "owner": "Chris", "deadline": null },
    { "text": "Draft release notes by Thursday", "owner": "Jordan", "deadline": "Thursday" }
  ],
  "decisions": [
    { "text": "Move the release to Friday" },
    { "text": "Skip the beta for this one" }
  ],
  "risks": [
    { "text": "If the API change isn't merged by Wednesday we might slip" }
  ],
  "prompt_version": "...",
  "schema_version": "..."
}

Sharing & Export

After extraction, you can export results in multiple formats or generate a shareable link.

• Copy all — copies the full structured output as plain text
• Export MD — downloads a Markdown file
• Export JSON — downloads the raw JSON response
• Export TXT — downloads a plain text file

Shareable links

Click Share link in the output footer to generate a permanent URL for your extraction. Share it via email, Slack, or any channel. Recipients can view the structured output without needing an account.

Troubleshooting

Common issues and how to resolve them.

Request timed out

Very long conversations may exceed the processing window. Try splitting your input into smaller chunks (e.g. break a 500-line thread into two halves) and extract each separately.

Empty or unexpected results

If the extraction returns no tasks, decisions, or risks, check that your input follows the "Speaker: message" format. Unstructured text without clear speaker labels may produce incomplete results. Try setting the source type manually instead of Auto.

Extraction Endpoint

The extraction API accepts raw conversation content and returns a structured ExtractionResponse. Use it to integrate Extraktr into your own tools and workflows.

For a single-page overview (production URL, curl, optional Bearer, CLI equivalence), see Public HTTP API.

Authentication

The free tier does not require authentication. Requests are rate-limited by IP address. Signed-in users should include their session token for account-scoped usage and higher limits than anonymous traffic; exact quotas and paid-tier benefits match the live Pricing page and server enforcement.

Request

Send a POST request with the conversation content and optional source type.

POST /api/extract
Content-Type: application/json

{
  "raw_content": "Chris: Move the release to Friday?\nMorgan: Yes, let's do Friday.",
  "source_type": "slack"
}

• raw_content (required) — the conversation text to extract from. Maximum 100,000 characters.
• source_type (optional) — one of slack, gmail, discord, teams, generic. Defaults to auto-detect.
• filter (optional) — object with optional fields: authors, channels, date_from, date_to, keywords.

Response

Returns a JSON object with summary, tasks, decisions, risks, and metadata.

{
  "summary": "Team agreed to move release to Friday.",
  "tasks": [
    { "text": "Send the calendar invite", "owner": "Chris" }
  ],
  "decisions": [
    { "text": "Move the release to Friday" }
  ],
  "risks": [],
  "follow_ups": [],
  "prompt_version": "v2",
  "schema_version": "1.0"
}

Response schema

Error codes

The API returns standard HTTP status codes. Error responses include a JSON body with a detail field.

Rate limits

Rate limits are applied per-user (authenticated) or per-IP (unauthenticated) to ensure fair usage and service stability.

When rate-limited, the API returns 429 Too Many Requests with a Retry-After header indicating how many seconds to wait before retrying.

Prefer the terminal? The CLI documentation describes the same POST /api/extract contract for shell and automation use, and the first-party extraktr CLI (published on npm).

CLI — Overview

The Extraktr CLI is a terminal surface for the same extraction engine that powers the workspace and the HTTP API—not a separate product. Use Extraktr in scripts, pipelines, or local workflows when you need structured output without opening the browser.

Same extraction engine. Browser, API, or terminal. The request contract matches Extraction Endpoint; output categories (tasks, decisions, risks, summary) align with Extract.

It is for:

• Developers integrating Extraktr into tooling
• Operators running repeatable extractions
• Automation workflows and scheduled jobs
• CI pipelines that validate or summarize thread exports
• Terminal-first users who already work in a shell

Supported workflows (HTTP client or npm CLI; same contract):

• File-backed thread text (--file)
• Piped stdin (--stdin)
• Optional Authorization: Bearer via --bearer / EXTRAKTR_BEARER
• Explicit source_type (slack, gmail, discord, teams, generic)
• JSON, plain text, or Markdown output via --format—renderings of the same result

CLI — Install

Version and release notes follow the npm package; see What's New for product updates.

CLI — Quick Start

The extraktr command posts to the same /api/extract route as the website. Examples below target production; set EXTRAKTR_BASE_URL for other hosts. From any shell you can also call the public HTTP API with curl.

npm package

Install globally, then run help and extract:

npm install -g extraktr

extraktr --help

Generic shell (file on disk):

extraktr extract --file ./thread.txt

PowerShell (Windows path):

extraktr extract --file C:\path\	o\	hread.txt

Stdin (PowerShell):

Get-Content C:\path\	o\	hread.txt | extraktr extract --stdin

JSON to stdout (valid JSON only—safe for jq):

extraktr extract --file ./thread.txt --format json

Write JSON to a file:

extraktr extract --file ./thread.txt --format json --output out.json

Without installing globally:

npx extraktr --help

curl (any machine)

curl -sS -X POST https://extraktr.com/api/extract \
  -H "Content-Type: application/json" \
  -d '{"raw_content":"Chris: Move the release to Friday?\nMorgan: Yes.","source_type":"slack"}'

From source (contributors)

To develop the CLI locally, clone the repo and run npm link from cli/; the extraktr command then points at your working tree.

Expected behavior

On success, the response is HTTP 200 with a JSON body matching the ExtractionResponse schema (summary, tasks, decisions, risks, metadata). On failure, you receive a 4xx/5xx with a JSON error body where applicable; curl exits non-zero for transport errors.

{
  "summary": "Team agreed to move release to Friday.",
  "tasks": [
    { "text": "Send the calendar invite", "owner": "Chris" }
  ],
  "decisions": [
    { "text": "Move the release to Friday" }
  ],
  "risks": [],
  "follow_ups": [],
  "prompt_version": "v2",
  "schema_version": "1.0"
}

CLI — Commands

The npm package extraktr provides the extraktr command; source lives in the repo at cli/index.js. Flags below match the published CLI.

extraktr extract

Runs one extraction; body is POST /api/extract with raw_content and optional source_type—same limits as Request.

Flags

• --file <path> — read conversation text from a file
• --stdin — read conversation text from piped stdin (not a TTY)
• --source <type> — optional source_type: slack, gmail, discord, teams, generic
• --format json|text|markdown — output shape (default text, or EXTRAKTR_FORMAT)
• --output <path> — write result to file instead of stdout
• --bearer <token> — optional Authorization (or EXTRAKTR_BEARER)
• --help / -h — usage

Input rules

• Use exactly one of --file or --stdin; combining them is an error.
• --stdin with an interactive TTY (no pipe) fails with a clear message.
• Empty stdin is rejected before the request is sent.

Help

extraktr --help
extraktr extract --help
extraktr --version

Global help covers commands; extraktr extract --help lists flags. extraktr --version prints the package version from npm metadata.

CLI — Output Formats

JSON — raw structured response (same object shape as the API). With --format json, stdout contains valid JSON only on success—no status or debug lines—so you can pipe to tools like jq or redirect to a .json file. Text and Markdown modes print only the formatted extraction to stdout on success. Errors and hints go to stderr.

Text — human-readable sections for summary, tasks, decisions, and risks (uses each item's text field). This is the default format.

Markdown — same data as compact ## sections for reading or diffs—not a second engine.

CLI — Authentication

The Next.js /api/extract proxy builds a backend Authorization header from your signed-in session when cookies are present. For scripts and the Node CLI (no cookies), you may send Authorization: Bearer … yourself—the proxy forwards it when the session bridge does not produce a header. The backend must accept that JWT (same contract as the bridge); there is no separate public API-key mint in this repo yet. Use a CLI/API token to associate usage with your account and receive higher limits.

Anonymous requests are subject to IP-based rate limits; the proxy forwards X-Forwarded-For and X-Forwarded-Proto so the API sees your client like browser traffic. Long-lived API keys for some automation flows are still planned—see Authentication under Extraction Endpoint.

Planned CLI auth: the released CLI will document how to pass tokens or configuration files explicitly; nothing in this section implies a secret mechanism exists before it is published.

CLI — Examples

Automation (npm CLI)

Pipe logs or exports into extraction as JSON:

cat logs.txt | extraktr extract --stdin --format json

Batch (bash)

Process many files (adjust paths as needed):

for f in ./threads/*.txt; do extraktr extract --file "$f" --format json --output "./out/$(basename "$f" .txt).json"; done

CI-style step

Write one JSON artifact per job (exit code non-zero on failure):

extraktr extract --file thread.txt --format json --output extraction.json

Extract from a local file (curl)

Build a JSON file with raw_content and optional source_type, then POST it:

curl -sS -X POST https://extraktr.com/api/extract \
  -H "Content-Type: application/json" \
  -d @./payload.json

Ensure payload.json is valid JSON and escapes newlines inside raw_content per JSON rules.

Pipe text (curl)

Without the CLI, wrap piped content into a JSON body in your shell. With the CLI installed from npm, use extraktr extract --stdin (see Quick Start).

Choose source type

Set source_type to match cleaning rules—useful for Slack-style Name: message threads pasted from exports.

Write JSON to a file

curl -sS -X POST https://extraktr.com/api/extract \
  -H "Content-Type: application/json" \
  -d '{"raw_content":"Chris: Move the release to Friday?\nMorgan: Yes.","source_type":"slack"}' > result.json

Markdown-style output

Use --format markdown with extraktr, or generate JSON and transform with your own templates.

CLI — CI / Automation

In pipelines, call the HTTP endpoint with curl or run extraktr with --format json --output. Check process exit codes; treat HTTP 429/5xx as retryable where appropriate. See the CI-style example under Examples.

• Keep thread samples under the same size limits as production API requests.
• Prefer --format json for machine parsing; stdout is JSON-only on success.
• Avoid hard-coding credentials; use CI secrets when authentication is required.

CLI — Troubleshooting

• No input — the CLI requires --file or piped --stdin; empty stdin is rejected.
• Conflicting input — do not pass both --file and --stdin.
• Invalid file path — --file must exist; --output must be writable.
• JSON mode and jq — with --format json, stdout is only JSON on success; avoid merging stderr into stdout (2>&1) when piping to jq.
• Invalid API input — 400: missing raw_content or text over the character cap.
• Malformed JSON file (curl) — validate payload.json before -d @file.
• Unsupported source type — 422 if source_type is not recognized.
• Rate limits — 429; back off using Retry-After when present.
• Network / TLS — non-zero exit; retry with connectivity checks.

What’s New

Recent updates and improvements to Extraktr.

Privacy Policy

Extraktr processes conversation content you submit for extraction. We do not store raw conversation data when you use ephemeral processing. We do not use your conversations to train models — processing is for your results only.

For signed-in users, extraction history and shared reports are retained in association with your account. You can delete your data at any time. Read the full privacy policy at /privacy.

Terms of Service

By using Extraktr, you agree to use the service responsibly. Do not submit content you do not have rights to process. Extraktr is provided as-is for conversation extraction. Read the full terms of service at /terms.