A keyword combiner is a string-pairing tool that produces every ordered combination of two short lists: if list A contains 50 terms and list B contains 20, the result is the full Cartesian product of 1,000 phrases, generated in first-seen order and capped at 10,000 pairs per request. The job is purely mechanical — paste, choose order, set the separator, then copy — and the tool deliberately does not estimate search volume, competition, intent, or grammatical quality. Every candidate still needs human review before it becomes part of an ad group, content brief, or taxonomy entry. Inputs are processed locally in the browser tab, so neither list leaves the device until the user clicks the copy button. The pairing rules are stable and deterministic, which means two identical inputs always produce identical text, and identical inputs in reverse order produce output you can diff cleanly. That property is what makes the result usable as a versioned artifact in a content brief, not just a one-off export. Use it when the bottleneck is enumeration, not judgment, and when you want to hand the next stage of work a clean, one-phrase-per-line text block.
What a keyword combiner actually does
A keyword combiner treats two lists as inputs and treats the pairing rule as the only logic. List A contributes one slot, list B contributes the other, and every A term is paired with every B term exactly once in the chosen order. With A-then-B and a single space, the phrase uses A as the head word; with B-then-A, the modifier moves to the front. The separator is a literal string, not a smart join — an empty string produces redshoes, a space produces red shoes, and a hyphen produces red-shoes.
The tool does not consult any external service while pairing. It does not query a search engine, advertising account, keyword-data provider, or AI service, so it cannot tell you whether "red shoes" is worth bidding on. What it can do is hand you the candidate set quickly so the next step — relevance review, demand validation, or landing-page fit — has a complete starting list rather than a sample. A small worked example: three colors paired with two product names yield six input pairs. With a space separator and A-then-B order, the block reads red shoes, red shirt, blue shoes, blue shirt, green shoes, green shirt. Six inputs in, six distinct phrases out, with 3 × 2 = 6 as the theoretical pair count and 6 as the unique output count. For readers who want the underlying math, the Cartesian product framing explains why A × B grows so fast and how the pair budget interacts with the cap.
Combine two keyword lists step by step
- Open Keyword Combiner and paste one keyword or phrase per line in list A (base terms) and one modifier per line in list B.
- Decide whether A should appear before B or vice versa, and type the exact separator — a space, hyphen, plus sign, or empty string — that should sit between the two halves.
- Click the combine action to generate the full Cartesian product in first-seen order, treating each non-empty line as trimmed and ignoring blank lines entirely.
- Review the audit summary for unique output count, normalized list sizes, theoretical pair count, removed input duplicates, and removed output collisions.
- Remove any irrelevant phrases from the visible output, then click the copy button to place the deterministic one-phrase-per-line block on the clipboard.
The whole flow is short on purpose. The hard part is what you do before pasting (clean lists, clear separator) and what you do after copying (relevance review, demand check).
Set the separator and respect the input limits
The separator is the smallest but most consequential setting. The same two lists with a space, a hyphen, an underscore, or no separator at all produce four visibly different outputs, and search engines treat those outputs differently even when the words are identical. Pick the separator that matches the syntax of the destination system rather than what reads best in plain English — for example, a hyphen for slug-style URLs and an underscore for some analytics tokens.
Empty separators are powerful but dangerous. When list A contains ab and list B contains c, the pair ab + c produces abc, and so does a + bc. Both are valid inputs, but they collide after concatenation. The combiner deduplicates these output collisions and reports the count separately from duplicate source lines, so an unexpectedly small result usually points to repeated source terms or colliding concatenations. Spaces inside the term, punctuation, accents, emoji, and non-Latin scripts are preserved verbatim — the tool only trims outer whitespace and rejects control characters, which keeps the result faithful to the source even when the lists contain Unicode terms.
| Limit | Value |
|---|---|
| Maximum length of one term | 100 Unicode code points |
| Maximum size of one editor | 100,000 UTF-16 code units |
| Maximum unique terms per list | 500 (case-sensitive) |
| Maximum length of the separator | 20 Unicode code points, no line breaks or control characters |
| Maximum input pairs per request | 10,000 — the next pair fails the whole request |
If a list has more than 500 unique terms, trim it before pasting. If the theoretical pair count exceeds 10,000, narrow either list so the request can complete rather than fail at the boundary. For more on deciding whether two words are even the right unit, this guide on building keywords from two lists walks through the same trade-offs from a different angle.
Read the audit summary before you copy
Every combine action prints a small summary block alongside the phrase list. Five numbers matter, and each one points at a specific kind of mistake.
| Summary field | What it tells you |
|---|---|
| Normalized list sizes | How many unique, non-empty terms each list actually contained after trimming |
| Theoretical input-pair count | List A size multiplied by list B size — the full Cartesian product before any deduplication |
| Removed input duplicates | Exact case-sensitive duplicates inside each list that were collapsed before pairing |
| Removed output collisions | Distinct input pairs that produced the same final phrase, typically because the separator is empty |
| Unique output count | The number of distinct phrases that will actually appear on screen and on the clipboard |
If the unique output count is much lower than the theoretical pair count, the most common cause is empty-separator collisions followed by repeated source terms. If it matches the theoretical count exactly, every pair survived deduplication, which is what you want for a clean audit. Treat the summary as the receipt: it is what you cite when explaining why the final list has the size it does, and it is also the place to look when the clipboard contents look shorter than the lists you pasted.
Treat the output as a candidate list, not a finished plan
The pairing step is the easy part of a keyword workflow. The hard part is everything that comes after copying. A phrase produced by mechanical pairing is not automatically a good target — it can sound unnatural, overlap in meaning with another phrase, or have no measurable search demand. Filter the block for relevance to the landing page, remove any phrase that violates policy or trademark rules, and confirm demand through first-party analytics, a paid keyword source, or a manual SERP check before turning the list into an ad group or a content outline.
Two practical habits make the downstream review faster. First, keep the order deterministic: when you rerun the same inputs, you get the same text, which lets you diff successive drafts and review exactly which phrases changed. Second, separate string combination from string judgment — run the combiner first, then load the result into a different tool or a spreadsheet where relevance scoring, demand lookup, and grouping are explicit steps. The combiner does not create Google Ads match-type syntax, add brackets, normalize capitalization, expand synonyms, stem words, or remove trademarked terms; any destination-specific formatting has to be applied downstream against the rules of the system that will consume the list.
The clearest signal that you used the tool correctly is a summary where the unique output count matches the theoretical pair count and the duplicate and collision counts are both zero. Anything else means the inputs need a second look — and that second look is usually faster than fixing a downstream campaign that was built on a partial or skewed phrase set.