Split text into sentences
Paste a paragraph and get one sentence per line: «Hello world. This is a second sentence! Is this a third?» becomes three lines. Repeated marks count as one ending, and a last line without a period is kept. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello world. This is a second sentence! Is this a third?
- Sentence count
- 3
- Lines
- Hello world. This is a second sentence! Is this a third?
- Operation
- split_sentences
A sentence splitter turns a dense block of prose into a clean list of sentences so you can review, number, edit, or feed each unit into the next step of a pipeline. Writers paste a draft and scan one sentence per line for length and rhythm. Teachers break student paragraphs into atomic claims before grading. Editors and localization teams isolate source sentences before translation memory lookup. Support and product teams turn ticket notes and release blurbs into reviewable units without opening a full NLP stack. This capability scans your plain text for terminal punctuation—periods, exclamation marks, and question marks—and returns both an ordered array of sentences and a newline-joined string ready to paste. Runs of the same terminal marks count as one ending, optional closing quotes are tolerated, and a final clause without a period still becomes its own sentence so informal notes are not dropped. Empty or whitespace-only input is rejected with a clear validation error instead of a silent empty list.
How the sentence splitter detects boundaries
The detector walks your plain text and treats a sentence boundary as a run of terminal punctuation characters drawn from the set period, exclamation mark, and question mark. A run such as three exclamation points or a question mark followed by an ellipsis-style period sequence is still one ending, so dramatic punctuation does not create empty fragments. Closing quotation marks or brackets that sit immediately after the terminal run are allowed and stay attached to the sentence they close.
After an ending, the next non-whitespace character begins the following sentence, and each segment is trimmed so leading and trailing spaces do not pollute the list. If the final clause of the text has no terminal mark at all, that trailing fragment still becomes one sentence, which matches how people draft messages and bullet-like notes without finishing every line with a period.
Abbreviations such as Doctor or Mister that use a period may split earlier than a human editor would prefer; treat the result as a fast terminal-punctuation split for review rather than a full linguistic parse.
Where sentence splits show up in real work
Writing coaches and secondary-school language arts classes break paragraphs into sentences so students can revise length, subject-verb agreement, and claim strength one unit at a time. Content marketers paste landing-page heroes and email openers to see whether short punchy lines or long stacked clauses dominate before an A/B test. Localization teams split source strings into sentence rows for translation memory and review queues, then reassemble after approval.
Support and legal teams skim policy snippets and ticket templates line by line to keep answers scannable. Product engineers gate form fields, review prompts, and chatbot training examples by expanding a blob into discrete sentences before acceptance checks. If you later need only a total without the list, a sentence-case rewrite, or a full word-and-character breakdown, treat those as separate search intents and landings rather than overloading this focused sentence-splitter page.
What you can do with it
Editorial review one sentence per line
Paste a draft paragraph and get each sentence on its own line so you can check length, rhythm, and clarity before publish.
Classroom and homework claim checks
Split student essays into individual sentences for peer review, auto-graders, or teacher scripts that score one claim at a time.
Localization and CMS sentence rows
Break source copy into sentence units for translation memory, CMS tables, and QA gates before reassembly.
FAQ
How does the splitter decide where a sentence ends?
It detects terminal punctuation: periods, exclamation marks, and question marks. A run of those marks counts as one ending. Optional closing quotes or brackets after the run stay on that sentence. A trailing clause without a final mark still becomes one sentence.
What happens if I send empty text?
Empty strings and whitespace-only strings are not allowed; provide a non-empty string to split.
Does this only count sentences?
No. This landing returns the actual sentence list and a one-per-line string. For a count-only total without the split list, use the separate sentence counter page.
What does it cost?
The browser tool is free and runs locally.
Does it handle abbreviations like Dr. or Mr.?
Not always. Every period is read as the end of a sentence, so a title written with a period can cause an early break. Read those lines before you use the result and join them back where needed.
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/str/split-sentences \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello world. This is a second sentence! Is this a third?"}'const res = await fetch("https://api.kit.forhosting.com/str/split-sentences", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello world. This is a second sentence! Is this a third?"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/split-sentences",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello world. This is a second sentence! Is this a third?"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/split-sentences", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello world. This is a second sentence! Is this a third?"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello world. This is a second sentence! Is this a third?"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/split-sentences", 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": "Hello world. This is a second sentence! Is this a third?"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.split_sentences",
"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. |
Technical notes
How the sentence splitter detects boundaries
Whitespace-only and empty strings are rejected with invalid_input so callers cannot mistake a blank paste for a successful zero-sentence split. The algorithm is a pure deterministic string scan: no random seeds, no wall-clock timestamps, no network calls, and no language model, so the same input always produces the same JSON.
What you send and what you get back
Send one required string field named text, or one of the documented aliases such as content, body, message, or input. The example payload in the contract is a short three-sentence sample so the free form and the API probe share a working case you can copy. On success the response echoes the original text, returns sentences as an ordered array of trimmed strings with terminal marks kept on each unit, repeats the length under sentence_count for quick checks, and builds lines by joining those sentences with newline characters so you get one sentence per line without post-processing. The operation field is always the constant split_sentences for logging and multi-tool dashboards. Missing text, empty strings, whitespace-only strings, non-finite numeric stand-ins, and objects that are not strings fail with invalid_input and are not charged. Very large payloads above the character cap are rejected with a clear length message so workers stay bounded. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance, which keeps exploratory probes cheap while you tune your inputs.
Where sentence splits show up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Technical questions
What is the difference between sentences and lines?
sentences is an ordered JSON array of each trimmed sentence. lines is the same list joined with newline characters so you can paste one sentence per line into an editor or review sheet.