A count occurrences alternative is a tool that counts how many times a literal piece of text appears inside a longer passage without forcing you to write a script or build a spreadsheet formula. Count Occurrences does exactly that: you paste up to one million characters of source text, type the string you want to find, pick case sensitivity, choose overlap behavior, and the tool reports a total count along with the first 100 starting positions of each match. Every match position is a zero-based JavaScript string offset, so position 0 means the very first character of the pasted text, position 1 means the second, and so on. Searching is purely literal, so a period matches a period and an asterisk matches an asterisk without any regex escaping. All matching runs locally in your browser, and neither the source text nor the search string is uploaded anywhere. This makes the tool a practical alternative for quick audits of logs, prose, source code, exported chat transcripts, or any text where you just need an honest count plus a few reproducible offsets.
What "count occurrences" really means for plain text
Counting occurrences in plain text is the act of asking "how many times does this exact substring appear inside this longer passage, and where?" The substring can be a single character, a word, a phrase, a separator, a code fragment, an ID, a log marker, or even an emoji. The output you actually need is a single number (the total) plus a handful of reproducible starting positions so you can verify the count by eye or by script. This is distinct from counting unique words, which is a job for a different kind of tool entirely. It is also distinct from regex matching, where a tiny pattern like colou?r can match "color" and "colour" through a single pattern. A literal count occurrences task treats every character in the search string as itself: a period is a period, an asterisk is an asterisk, and square brackets have no special meaning. That literalism is the feature that makes the result easy to predict, easy to explain to a colleague, and easy to reproduce in your own code.
Why people look for a count occurrences alternative
Most readers land on this topic because the obvious approaches have friction. Spreadsheet formulas such as COUNTIF expect structured cells and require careful quotation marks around text criteria, which trips people up the moment a search string contains a comma, an apostrophe, or a line break. Command-line tools can produce a count, but they demand terminal access, the right flags, and a willingness to read the manual. A short Python script using s.count() is fine for a developer who already has an editor open, but it pulls in setup, file I/O, and the silent assumption that non-overlapping matches are what you actually want. A JavaScript one-liner using repeated String indexOf calls is closer to the truth, but still expects you to choose overlap behavior and to write the offset bookkeeping yourself. None of these are wrong; they simply push work onto the reader. A browser-based alternative like Count Occurrences removes that setup, hides no flags behind a flag, and gives back a number plus the first 100 offsets in one screen.
How to count occurrences with this browser tool
- Paste or type the source text you want to search into the larger text area. The tool accepts up to one million characters.
- Enter the literal text you want to find in the search field. You can include spaces, tabs, line breaks pasted into the field, emoji, or ordinary Unicode up to 1,000 characters.
- Choose case sensitivity: keep "case-sensitive" on for exact comparisons, or switch to "case-insensitive" to fold English-locale lowercase before matching.
- Choose overlap behavior: "overlapping" advances one JavaScript string unit after each match, while "non-overlapping" advances by the full length of the search string.
- Run the count. The result reports the total number of matches (singular or plural as appropriate) and lists the first 100 zero-based starting positions.
- Edit any input or toggle any option if you need to refine the search; the old output clears automatically so stale counts cannot be mistaken for the current settings.
The whole flow runs locally, so neither the pasted passage nor the search string is sent to a server. If you only need a count of whole words rather than a specific string, the Word Counter covers that case instead.
Overlap mode versus non-overlap mode
The two overlap options look like a small toggle, but they answer genuinely different questions, so it is worth picking deliberately. Non-overlap mode treats each match as a chunk and skips past the entire search string after a hit, which mirrors how many simple "replace all" operations behave in word processors and editors. Overlap mode instead advances only one string unit, which is the right choice whenever the same substring can sit inside itself, as with runs of identical characters, repeated delimiters, or sequence analysis.
| Mode | What happens after a match | Typical question it answers |
|---|---|---|
| Non-overlap | Advance by the full length of the search string | "How many separate replacements would a simple literal replace make?" |
| Overlap | Advance by one JavaScript string unit | "At how many starting positions does this substring appear?" |
For example, searching for aa inside the source text aaaa produces two matches in non-overlap mode (positions 0 and 2) and three matches in overlap mode (positions 0, 1, and 2). The total you see in the tool reflects whichever mode is active at the moment the count runs.
Case sensitivity and zero-based positions, explained
Case-sensitive matching compares the search string to the source text byte-for-byte, which means Error and error are reported as different matches. Case-insensitive matching uses String toLocaleLowerCase on both strings before searching, which is a practical choice for English prose and most source code. Locale-specific rules (Turkish dotless i, German sharp s, accent folding, and Unicode normalization between composed and decomposed forms) are intentionally not inferred; the tool is a text utility, not a linguistic collation engine. Whatever case mode you pick, the reported offsets always refer to the original source text, not to a normalized copy.
Zero-based positions count from the start of the source string, so position 0 is the very first character, position 1 is the second, and position n sits one code unit before a match that begins at the n+1th character. These are JavaScript UTF-16 string offsets, which matters when the source contains characters represented by surrogate pairs: an emoji such as 🙂 can consume two code units rather than one perceived character, and the offset numbers shown reflect that. For most ordinary English text the offsets look exactly like the intuitive character index, but for prose, code, or chat logs that mix scripts and emoji, the surrogate-pair rule is the reason an offset can look "one too high" for a single visible character.
Where a count occurrences alternative pays off
The tool is well suited to any task where the search string is fixed and literal. Common uses include checking how many times a repeated word appears in a draft, auditing a server log for a known marker string, counting occurrences of a separator inside a CSV export, tallying a specific ID inside a JSON dump, or measuring how often a punctuation pattern shows up in source code. Because the search runs locally and the matching is literal, it is also a clean fit for sensitive snippets that you would rather not paste into a web API. A related angle from a position-first perspective is covered in the guide Count Occurrences of a String in Text and See Positions, which walks through the same tool from the perspective of inspecting starting offsets.
Limits and what this tool does not do
Count Occurrences is a literal counter, not a search engine. There is no regular-expression syntax, no fuzzy matching, no stemming, no wildcard syntax, no whole-word mode, no Unicode normalization between composed and decomposed forms, and no accent folding. The tool does not replace matched text; for that, Find and Replace is the right neighbor. It does not compare two bodies of text; that is the job of the Text Diff Checker. The source text is not trimmed, line endings are not rewritten, whitespace is not collapsed, and duplicates are not removed, which means the count you see is the count of the literal characters you pasted. An empty search string is rejected because it would otherwise match at every boundary and produce an ambiguous total. The position preview is capped at 100 entries so a result with hundreds of thousands of matches remains readable on screen, but the reported total is never truncated. Singular and plural labels track the actual count, and a zero result is treated as a valid answer that simply lists no positions.