Combining two keyword lists means producing every ordered pair between them — a deterministic Cartesian product in first-seen order, with a literal separator inserted between the two terms and the full result copyable as a single block. The operation is mechanical: each non-empty line in list A is joined to each non-empty line in list B exactly once, in the order you choose, and the resulting phrases are deduplicated while keeping the first occurrence. Nothing else is added. The tool does not estimate search volume, infer user intent, normalize capitalization, expand synonyms, or attach match-type syntax. It does not call a search engine, an advertising account, or a third-party keyword provider. A line in list A containing "red" joined to a line in list B containing "shoes" with a space separator produces exactly one line: "red shoes". The behavior is identical on every run, so the same input always produces the same output, which makes the result suitable for version comparison and deterministic tests. The hard ceiling is 10,000 input pairs before output deduplication — if A×B exceeds that, the whole request fails instead of returning a partial sample, so no result is silently truncated, paginated, or replaced with an ellipsis.
What Combining Two Keyword Lists Produces
A keyword combiner takes two one-per-line text lists and returns every ordered pair between them. The mathematical term for that operation is the Cartesian product: if list A has 3 unique terms and list B has 2 unique terms, the theoretical input-pair count is 3 × 2 = 6. Three colors — say "red", "blue", "green" — combined with two product names — "shoes", "hats" — produce six input pairs: "red shoes", "red hats", "blue shoes", "blue hats", "green shoes", "green hats". After output deduplication, those six remain six because no two concatenations collide in this case. The same operation with a different separator changes the surface text without changing the pair count: an empty separator turns "red" + "shoes" into "redshoes", while a hyphen produces "red-shoes". The mathematical structure of the result is the same; only the visible string changes. Readers who want the formal background can review the Cartesian product definition in a separate primer on combination keywords in math.
Prepare List A and List B Correctly
The quality of the output is set before you press combine. Each editor accepts one term per line, splits on any mix of CR, LF, or CRLF, trims outer whitespace, ignores empty lines, and rejects control characters. Each term may contain up to 100 Unicode code points, and each editor accepts up to 100,000 UTF-16 code units of pasted text. Each list is capped at 500 unique case-sensitive terms. Exact case-sensitive duplicates inside a single list are removed while preserving the first occurrence, so "shoe" and "Shoe" remain distinct if both were pasted on purpose. Internal spaces, punctuation, accents, emoji, and non-Latin scripts pass through unchanged. If you paste a comma-separated column from a spreadsheet, the commas stay inside the term and the whole cell becomes one line — split on line breaks first if you want commas to act as separators.
- Decide whether list A is the fixed half (a product, a city, a brand) and list B is the modifier half (a color, an audience, an intent word), or the reverse, before you paste.
- Strip trailing semicolons, footnote markers, and accidental tab characters in a plain-text editor first.
- Keep terms short and consistent. A 12-character noun will combine more predictably than a long clause, even though a 90-character line is allowed.
- Reorder lines in first-seen order so the resulting pair list mirrors the order you actually want to review.
Pick Order, Separator, and Run the Combine
- Open the Keyword Combiner in your browser. Nothing is uploaded — the lists stay in the current tab.
- Paste your fixed half into list A and your modifier half into list B, one term per line. Empty lines are ignored automatically.
- Choose A-then-B if list A should come first in the phrase ("red shoes"), or B-then-A if list B should lead ("shoes red"). Switching the order also reverses the loop order, so the resulting pair list changes consistently and remains easy to diff against a previous run.
- Enter the exact separator between the two terms. The separator is a literal of up to 20 Unicode code points and cannot contain a line break or control character. Common choices: one space, a hyphen, a plus sign, an underscore, or an empty string for glued concatenations.
- Run the combine. The tool computes the theoretical A×B pair count first, builds every pair deterministically, and removes exact output collisions in first-seen order.
- Read the summary: unique output count, normalized list sizes, theoretical input-pair count, removed input duplicates, and removed output collisions.
- Copy the result as a single block, one phrase per line, into your spreadsheet, ad-group draft, content brief, or taxonomy document.
Read the Pair Counts Before You Copy
The summary block tells you exactly what happened during the combine. Five numbers matter: the normalized count for list A, the normalized count for list B, the theoretical input-pair count (A × B), the number of input duplicates removed inside the two lists, and the number of output collisions removed after concatenation. If the unique output count equals the theoretical input-pair count, every pair produced a unique phrase and nothing collided. If the unique output count is smaller, two or more input pairs produced the same final string — common with an empty separator, where "ab" + "c" and "a" + "bc" both yield "abc". In that case the tool keeps the first output and reports the rest as collisions. If the unique output count is unexpectedly large, narrow the source lists before copying. If it is unexpectedly small, check for repeated terms or colliding concatenations. The pair budget is calculated before output deduplication: any request that would generate more than 10,000 input pairs fails the whole request instead of silently keeping only the first 10,000 pairs. That explicit ceiling is what prevents a request that is nominally too large from slipping through only because several strings later collide. A small worked example using a documented case: three colors combined with two product names give a theoretical input-pair count of 3 × 2 = 6. If your summary shows 6 input pairs and 6 unique outputs, the combine is clean. If it shows 6 input pairs and 5 unique outputs, exactly one concatenation collided and was reported separately.
What the Combiner Deliberately Does Not Do
The tool is a string-combination utility, not a keyword research product. It does not estimate search volume, competition, cost per click, intent, language, or grammatical quality. It does not query an advertising account, search engine, keyword provider, or AI service. It does not create Google Ads match-type syntax, wrap phrases in quotes, add brackets, normalize capitalization, expand synonyms, stem words, or remove trademarked terms. The rules of the destination system are your responsibility: a phrase generated here is a candidate, not an approved target. Some combinations will sound unnatural, overlap in meaning, or have no measurable demand. The distinction keeps a string-combination utility from pretending to be keyword research. Treat the output as a list that still needs human review and, when appropriate, first-party analytics data or paid keyword evidence. Internal capitalization, accents, and punctuation are preserved exactly as pasted. If you need the phrase to start with a capital letter, normalize it yourself after the copy step.
Separator Choices at a Glance
A quick reference for the most common separator inputs, using the same two terms "red" and "shoes" with the same A-then-B order. The columns show the literal output, not a computed total — these are officially supported literal transformations, not bulk arithmetic. The pair count is identical across all rows: one input pair, one output phrase with no collision in this minimal case.
| Separator value | Result for "red" + "shoes" |
|---|---|
| Empty (no characters) | redshoes |
| One normal space | red shoes |
| Single hyphen (-) | red-shoes |
| Single plus sign (+) | red+shoes |
| Single underscore (_) | red_shoes |
| Literal string " in " | red in shoes |
These six rows cover most ad-group, content-brief, and slug conventions. Choose a hyphen or underscore for URL slugs, a space for natural-language ad copy, an empty separator only when a glued compound is the goal, and a longer literal like " in " or " for " when the brief calls for a prepositional phrase. Whatever you choose, the separator is applied verbatim — no hidden spacing is added or trimmed.
Where the Output Goes After the Copy
The deterministic one-per-line output is meant to drop into a destination that already has its own rules. Common uses include: pasting into an ads editor as a starting set for an ad group, with manual match-type syntax added after; pasting into a content brief where each line becomes a section heading or H2 candidate; feeding a taxonomy review by joining a category axis to a qualifier axis; or seeding a separate analysis in a tool that expects plain text per line. Because the combine is deterministic, the same input pasted tomorrow produces the same output today, which makes the result suitable for version control: store the source lists in a file, run the combine, commit the output, and diff future runs. The lists themselves are not uploaded or stored by the widget, and copying happens only when you press the copy button. If the destination requires match types, quote wrapping, or trademark screening, apply those rules downstream. A list generated here is the input to that work, not a replacement for it.