Permanently protected template

Template:Search link

From Wikipedia, the free encyclopedia
Jump to: navigation, search

Template documentation[view] [edit] [history] [purge]
"Template:Sl" redirects here. For the template for linking to sections, see Template:Section link.

This template creates a link that can be used to store a Wikipedia search box query. A search link is useful for collaborative search on Talk pages and most other pages, but it is not to be used in articles. If used in articles, it outputs the above warning.


{{Search link|first|second|third}}

  • The first parameter is for the search, or query.
  • The second parameter is a label for the link.
  • The third parameter is the search domain.

The name of the template is Search link, or sl for short.
The second and third parameters are optional and have defaults, so the short form is {{sl|query}}.

Both a search link and a search box go to the same search engine. The same query produces the same result.

The basic search covers articles. It finds words and phrases composed of letters and numbers very quickly, but a basic search can also query for all articles that contain a string that includes punctuation, math, and other symbols as seen in the page content or as seen in the page wikitext.

Basic search principles when using a search link
1 {{Search link
|"search engine query"}}

"search engine query"

There is one search term, a phrase that produces 18 results, including a redirect. For one term, the page ranking rule is simple: title matches, on top. Two pages hit on "Search Engine Query" and one on "[[Search engine (computing)|search engine]] query".
2 {{Search link
|"search engine query"

insource:/"search engine query"/}}
"search engine query" insource:/"search engine query"/

Added a term: insource:/"slash delimited regex"/. Now there are 15. Three were filtered out because regex match only exact strings. All other searches always ignore capitalization, punctuation, math, and other symbols, like the ]] above. Proves a basic difference with search 1: only insource: searches wikitext. All other terms search what is rendered.
3 {{Search link
|search engine query}}

search engine query

There are three search terms. They produce 1169 results. Many page ranking rules apply to make the top most likely and the bottom least likely, probably.
4 {{Search link
|search engine query
insource:/"search engine query"/}}

search engine query insource:/"search engine query"/

Similar to search 3, the regex crawled character-by-character through the same 1169-page filter to produce its same 15 results. That's nothing compared to what would happen if you ran an unfiltered (unaccompanied) regex exposed to the 30 million pages on the wiki to produce just 15 results.[1]
5 {{search link
|insource:/"2 + 2"/
|"Arithmetic" titles & "2 + 2"}}

"Arithmetic" titles & "2 + 2"
The regexp is the first term, but the prefix: term first filters out all but a few titles that start with the characters A-r-i-t-h-m-e-t-i-c, then the regexp crawls character-wise. Perhaps such a label conveys this to your team.

This template differs from the search box superficially when searching for an equals sign. In the search box you just say =, but here you must use the five-letter string {{=}}.[2]

In search 5 notice the need for the double quotes around the search pattern: insource:/"slash delimited regexp"/. These protect any characters from being interpreted as regex metacharacters, and insures they are interpreted literally. In basic searches quotes are always used, to enable exact-string searches in the wikitext. In advanced searches the double quotes are not used, so that the metacharacters can act as conditional and branching operators to create generalized patterns. Especially note also the prefix: filter used. We use filters with regex searches.

Search 2 exemplifies the easiest filter to apply to accompany any regexp search. It just takes the same phrase and make it a separate term. Given any regexp insource/"exact string search"/, just accompany it by an insource:"exact string search". The later term will always act like a perfect filter, matching every alphanumeric, and ignoring every non-alphanumeric, speeding through an indexed search to filter out pages the regexp couldn't possibly match. A namespace name at the beginning is another easy filter to apply, but any additional term in the query is a needed regex filter.

The next section covers Search link arguments more in depth.


For more details on Search engine queries, see Help:Searching.

Here are the template parameters for Search link.

1 or |query= The search query. It becomes the text of the search link (how the link will look) so it accepts |text=.
2 or |label= A label to replace the default text. A new look to the link, so it also accepts |link=. Defaults to show the search query.


or |ns=

The search domain: one or more namespaces abbreviated "nsx", where x is any namespace number.
|nsx|nsx|nsx|…|nsx, or ns=nsx&nsx&nsx…&nsx, or ns=all. Defaults to ns0.

limit= Number of search results on the first page. Named parameter only; for use when you already know the number of results.
Wikipedia namespaces
Subject namespaces Talk namespaces
0 (Main/Article) Talk 1
2 User User talk 3
4 Wikipedia Wikipedia talk 5
6 File File talk 7
8 MediaWiki MediaWiki talk 9
10 Template Template talk 11
12 Help Help talk 13
14 Category Category talk 15
100 Portal Portal talk 101
108 Book Book talk 109
118 Draft Draft talk 119
446 Education Program Education Program talk 447
710 TimedText TimedText talk 711
828 Module Module talk 829
2300 Gadget Gadget talk 2301
2302 Gadget definition Gadget definition talk 2303
2600 Topic
Virtual namespaces
-1 Special
-2 Media

You only ever need to use parameters 3–20 if you want a profile of two or more namespaces for a search domain. Otherwise you can just say the namespace name (or all) at the beginning of the query, or a prefix parameter at the end of the query.

When the query goes through this template, the default search domain is article space, just as it is for basic users. The default search domain of a user, logged-in or not, is article space unless the user set there preference.[3] But no matter who uses a search link the results will always be the same. "Cut and paste" can never guarantee the same results for a search, but a search link can because the search domain is just article space for everyone, or search domain is the set of namespaces you set for everyone.

If you know the numbers of your search domain profile, you just type them in ns=ns0&ns1&ns2600. (You can get them from the namespace table to the right.) Otherwise you refine your query and search domain on the search results page, whose Advanced interface is designed to select and adjust namespaces with no knowledge of the namespace numbers. Once that produces satisfactory results, you copy the namespaces string from the URL (in your browser's address bar), and paste it into |ns=, and you can get the query from the search results page search box, and paste it as the query, and that's your search link.

If you have just one namespace in your search link, and it's not article space, you can specify it by saying, say, ns=ns10, or |ns10" at parameter position 3 or greater:

{{sl|"search link" namespace||ns10}}"search link" namespace

For one namespace the explicit name is preferred:

{{sl|Template:"search link" namespace}}Template:"search link" namespace

The explicit name is preferred if you will be publishing or saving your search link. That way when it is run later the search domain shows up explicitly at the beginning of the search box of the search results page to inform the user. Otherwise only the URL and only the namespace-profile dialog frame pops up on the search results page to inform the user. When it is two or more namespaces, these things always happen, because the query only accepts one namespace (as the first term only). But all is also an informative query, a pseudo-namespace for Search only. If you see a query begin with all:, the URL will be loaded with all the namespace parameters.

You can use "all" in {{Search link}} to specify all namespaces:


but again, it is far more preferable to say

{{sl|all:"search link" namespace}}all:"search link" namespace

than it is to use:

{{sl|"search link" namespace||all}}"search link" namespace

for the reasons given just above. But when specifying "all", the query time is about seven times greater because there are that many more pages on the wiki than there are articles. If a more targeted search is possible, it runs much more quickly than the "all" search.

For example, if you have a query for which know the search domain is 10 and 11, and you want no label, then you need a parameter 3, but you need no parameter 2, so per the template parameter rules the search link can be made in four general ways:

  • {{sl|query||ns10|ns11}} When parameter 1 unnamed, and parameter 2 is unnamed | | (defined as the "empty string"), then parameter 3 can be defined unnamed ns10, and parameter 4 can be defined unnamed ns11, and so on. Nothing is named because everything is defined.
  • {{sl|query|3=ns10|4=ns11}} Parameter 2 is undefined, but that's fine because parameters 3 and above are all named...
  • {{sl|query|ns=ns10&ns11}} or the empty positional parameter | | is not needed when |ns= defines itself named.
  • {{sl|query=query|label=|ns=ns10&ns11}} Everything is explicitly named.

For another example, if you select the "Wikipedia" and "Help" namespaces, then run a query, the URL will show ns4=1&ns12=1. Copy that and paste it to |ns=ns4=1&ns12=1. (Note: you can ignore the "=1" part from the URL.)

Note how the URL contains ns0, ns1, ns2, and ns3, and how it got them:

{{sl|systems operations|3=ns2|4=ns1|ns=ns3|20=ns0}}systems operations
{{sl|query = systems operations|||ns2|ns1|ns3|ns0}}systems operations
{{sl|systems operations|3=ns2&ns1&ns3&ns0}}systems operations

If you need to develop a highly specific search domain, a very elaborate one carved out of a set of the thirty namespaces, then you will have developed this at the search results page using the Advanced search domain picker there. Then you just cut and paste the entire string from the URL of your found search domain namespaces, and paste it into one named parameter |ns=.

To type in namespaces 0, 2, 4, 5, 7 and 9, with no label, the two easiest ways are:

  • {{sl|query||ns0|ns2|ns4|ns5|ns7|ns9}}
  • {{sl|query|ns=ns0&ns2&ns4&ns5&ns7&ns9}}

The order is irrelevant.

Advanced examples

All these involve insource:/slash delimited regex/ with filters. Any search link with an insource:/regex/ search should always provide the additional query terms that would filter (reduce) the search domain as much as possible. This template defaults to article space if no namespace is given, which is a filter.


The need to match an equals in an article is not surprising, and is basic. You have to use {{=}} or |query= or |1= just to get the equals sign in your query to the search engine, or {{!}} to get the pipe character to the search engine. Both pipe characters and the equals signs are template sensitive for all templates, so you can always quote them with curly brackets like that inside templates. Although the search box can take = and | directly, quoting is necessary in the search link because otherwise they have their parameters meaning.

Regex are sensitive to punctuation, brackets, math and other symbolic characters, collectively known as "punctuation" so you quote them, because otherwise they have their regex metacharacter meaning. The "metacharacters" of CirrusSearch have claimed most punctuation characters as functions in their regex, but you don't have to know all the metacharacter functions just to search for them as targets literally. You can simply quote all punctuation to search for them as literal targets in wikitext. The way to easily quote every character in an entire regexp is to put the whole term in quotes: insource:/"regexp with literal characters"/

To get a pipe character through both the template and the search engine to target it as a character in wikitext, you have to quote it twice, hence the frequent need for the six characters \{{!}} in an advanced search link. The equals sign is not a metacharacter, so it does not have to be quoted twice, as the pipe character does. The pipe character is a metacharacter that means OR.

To generate advanced regex searches, see about doing so at {{regex}}.

Search engine features

The search engine can

  • sort by date
  • fold character families. An e matches an ë, and Aeroskobing matches Ærøskøbing.
  • understand when a page linksto or hastemplate, or has something intitle, or is incategory
  • understand OR and AND, and two forms of not.
  • perform fuzzy searches on word spellings.
  • locate words as near to each other as you specify.
  • find wildcard expressions and regular expressions.

A search matches what you see rendered on the screen and in a print preview. The raw "source" wikitext is searchable by employing the insource parameter. For these two kinds of searches a word is any string of consecutive letters and numbers matching a whole word or phrase. All other keyboard characters like punctuation marks, brackets and slashes, math and other symbols, are not normally searchable.

By default Search will also stem the words and match them too. It automatically sorts results by the frequency and location of these, but also can boost page ranking by time, template usage, or even similarity to other pages.

Search is a search engine that does a full text search by querying an index database. It offers search syntax and parameters exceeding the capabilities and control of other public search engines that could search Wikipedia.

Page score

Say the search box is given two words. The search starts with two index lookups, and the two results are combined with a logical AND. But before they are displayed as search results, they must all be assigned a final score before the top twenty (listed on the first page) can be displayed, and they must be formatted with snippets and highlighting. Page ranking deals quickly with very large numbers of pages, by approaching things statistically, and taking several swipes through the data.

  1. The frequency and location of each word determines the first sorting.[4]
  2. The order of the words determines the second sorting. If the two words happen to be found in the same order on a page, that page is boosted again.
  3. The number of incoming links.[5]

These attributes for a word earn that page a higher score:

  • position in the title
  • position in the lead section
  • repetition
  • close proximity to other words in the query

There can be several other scoring mechanisms. The parameters that you can control are morelike, boost-template, and prefer-recent.

General description

There are now eleven parameters for various approaches to searching the many namespaces. Four of the seven new parameters now offer to target these page characteristics: hastemplate and linksto, insource and insource:/regexp/. The other three now offer to target page ranking: morelike works all alone, a prefer-recent term can be added to any query, and there is now also a boost-template parameter. The other four, preserved in name only, from the entirely rewritten previous version of Search, are intitle, incategory, prefix, and namespace.

Any search will feature one of these approaches

  • Rely on page ranking; ignore most results; run once.
  • Search for an exact string using a simple regexp; pretest a small search domain.
  • Hack out a highly refined set of page characteristics with concern only for an exact count of pages; refine in a sandbox and on the search results page.

The concept of a search domain plays an important part in all this. By default it is just article space, but in general a search domain starts out as a set of namespaces, and ends up as all the pages in the search result.

One term of a query will set the search domain for another term in the same query. The order is optimized by the search engine. The query term1 term2 transforms the search domain twice to get those search results. For example, a bare namespace returns the pages of the namespace. The query term1 term2 regexp relies heavily on the first two terms to reduce the search domain size.

All terms in a query are indexed searches unless they are a regexp. Indexed terms run word-wise instantly, and a regexp runs character-wise slowly. Even the most basic use of a regexp, just to find an exact string, should always limit the size of its search domain to as little as possible. This can be as simple as adding a few terms, (as covered below), because each term in a query tends to reduce the number of pages. Never run a bare regexp on the wiki especially if your user profile is preset to Everything. The search engine limits the number of regexp searches that can run at once. Without the proper filter running alongside a regexp it will run for up to twenty seconds, and then incur an HTML timeout.

On the search results page, the initial search domain on which the query was run is indicated by the following, given in increasing power to override the others:

  • an open namespace dialog if the user has preset a profile of namespaces
  • Content pages or Multimedia or Everything: if one of them was the initial search domain, then the color of that one's text will have turned from (link-colored) blue to (presentation) black.
  • a namespace parameter in the query
  • a prefix parameter overrides them all.

For example, if the namespace parameter is all, the size of the initial search domain will be the 39,863,529 pages in all namespaces: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 100, 101, 102, 103, 104, 105, 106, 107, 460, 461, 490, 491, 828, 829, 1198, 1199, 2300, 2301, 2302, 2303, 2600 A prefix parameter specifies just one of those namespaces, in whole or part. If the initial search domain is the default, Content pages its size is the 5,205,530 pages in namespace 0, (article space).

A search can be set into a link to specialize and share searches: [[Special:Search/search]]. Such a query should always be a fully specified by specifying an initial search domain so as to avoid user profile discrepancies. This way it gives the same results. For example, if more than one namespace is needed, use {{search link}}.[6]

Other helpful approaches to the search engine features are

  • templates such as {{template usage}} that offer pre-made specialized searches.
  • Input box setups, such as the one at the bottom of this page, that can perhaps be made to work with such templates.
  • driving new or improved feature requests at phabricator


Greyspace characters are the non-alphanumberic characters: ~!@#$%^&*()_+{}|[]\:";'<>?,./. Any string of greyspace characters and/or whitespace characters is "greyspace".

Greyspace is ignored except where it has meaning as a modifier in syntax.

  • +term turns off "Did you mean" suggestions
  • _term turns off "Did you mean" suggestions for that term
  • -term means not. It changes the meaning from include to exclude.
  • !term also means not.
  • The colon : character can specify the "article space" as the search domain, and it can, in some cases, act as a letter or number when inside a word (non-spaced). These are covered below.
  • The tilde ~ character associates generally to finding more search results:
    • ~query guarantees search results instead of navigation.
    • word~ does a "fuzzy search" for that word.
    • "exact phrase"~ adds stemming for each word.
    • "exact phrase"~n does a "proximity search", allowing n extra words inside the exact wording.

Parameters also accept words and phrases, but each can search there own index and interpret there own arguments, such as for

  • requiring a namespace or not, or accepting namespace aliases or not
  • reporting redirects or not
  • for a pagename input: being case sensitive or not, or accepting the underscore _ character in lieu of a space character or not
  • delimiters for there arguments
  • the meaning of their own modifier characters syntax

The delimiters:

  • Namespace needs no delimiters, but accepts whitespace to the left and greyspace to the right
  • Prefix accepts only whitespace between the namespace and the pagename, and accepts greyspace to the left.
  • insource:/arg/ requires no space, but all other parameters tolerate at least whitespace
  • Two words separated only by greyspace characters make a greyspace phrase, subject to stemming
  • "Double quotes:" make an exact phrase, and make stemming and proximity possible with more modifiers added
  • Greyspace is ignored:
    • anywhere inside double quotes
    • in starting characters of the search box query, but not before a namespace
    • between words and phrases, except for greyspace phrases
  • Space characters are important only
    • for pagenames (linksto, prefix, incategory, boost-templates, morelike).
    • between two parameters (to delimit the argument)

Colon : character:

  • as a namespace, it means article space
  • as a prefix, it means article space
  • to insource or "exact phrase" it means a literal colon and acts just like a letter or number if it is an non-spaced colon.

Word and phrase

A search is a query with one or more terms. The query does not actually search the page database, but rather, a search queries a prebuilt, constantly maintained, search index database. When creating the search index of words on the wiki, or when entering a query, a word boundary is greyspace. Greyspace characters can create a multi-word_phrase. We must say tab and newline even though we cannot put those characters in our query; this is because of the important fact that the same analysis that is done on the wikitext is also done on the query. A word boundary is whitespace characters (tab, space, or newline) or greyspace characters. Greyspace characters and whitespace characters are all folded together as one, just as special characters like æ (ae) or á (a) are folded into the standard keyboard characters.

A phrase expresses an ordering of words,[7] and there are three ways to make one, depending on how aggressively you want the phrase to match.

  • "quotation marks"
  • joining_with_non-alphanumeric(characters)
  • camelCaseNaming or letter222number transitions

"Quotation marks", phrases are called an "exact phrase" because it is exact wording: stemming, fuzzy search, and wildcards are not used in an "exact phrase". Like the rest of Search, an "exact phrase" tolerates greyspace between words. Joining_with_non-alphanumeric(characters) only, will employ stemming on the words. CamelCaseNaming or letter222number transitions, matches the phrase in greyspace, with stemming, and additionally matches the word itself. Parameters can require the quotation marks to include whitespace in their input.

The wikitext is searched by employing the insource parameter. The insource parameter ignores greyspace characters too.

For example, to find the phrase, use, or use insource: "http en wikipedia org wiki search engine".

When you search for a word, that word is just looked up in an index. An indexed search instantly concludes with all search result titles, without having to search the wiki itself.

Each word you see in a page's content (a title's content) is already in an index, where it points to all its other prearranged results. A word is indexed to a list of page names, where it is seen in the text, or it is seen in the title only.

Each indexed word is seen as a string of alphabetic characters a-z, or a string of digits 0-9, or a string of alphanumeric characters a-z, 0-9. a token inside a camelCase word.

For transitions from lower to upper case, (or camelCase), and transitions from letter to number:

  • these are two words
  • only the first transition divides such words, into two
  • a null space matches non-alphanumerics: game-folks matches gameFolks.

for or digit-letter these match singly or together. In other words you don't need the space, but that also works to find either "word" of a camel case or mixed alphanumeric word. You don't need a space, and non-alplhanumeric characters are treated as that null space.

We may call these "word" characters or "alphanumeric" characters at times as opposed to the "non-word" characters, which are ignored except as to function as a word boundary. Usually a word boundary is just a space character.

These words are case-insensitive: a-z is equivalent to A-Z, so Search box will navigate to a pagename regardless of capitalization, (even though wikilinks and URL's must match capitalization apart from the initial character).

Each word is aliased to all its word-stems, so cloud, clouding, clouds, clouded, cloudy will all point to the same index entry.

In Search the characters !@#$%^&*()_+-={}|[]\:;'<>,.?/ are ignored. Any mix of whitespace characters and these non-word characters, we may refer to as grey-space. Grey-space, then, is all non-word characters except the double quote character, which is not ignored.

Grey-space is a string of one or more characters such as brackets and math symbols and punctuation and space. Now, a search-indexed word will be found between grey-space, and grey-space is an implied AND of two words in a search query, but the AND is not always implied: when two phrase exist side-by-side the AND is required.

Exceptions to what "words" are indexed are these portioned words:

  • A change from a numeric to an alphanumeric character is an additional word boundary in an alphanumeric word.
  • A change from an alphanumeric to a numeric character is a word boundary in an alphanumeric word.
  • A change in case from lowercase to uppercase is a word boundary in an alphabetic word.

The word boundary between such numeric portions and an alphabetic portions may include grey-space or not, but a phrase search turns off portioning, because it is an "exact phrase search", the words in the phrase matching only alphanumeric words delimited by grey-space.

Words joined only by non-alphanumerics are treated like a phrase. So word1_word2&word3 is the same as "word1 word2 word 3". However they will also match camelCase and letter-number transitions. An exact phrase search will not match camelCase or letter-number transitions. For example, terms like wgCanonicalNamespace and !wgCanonicalSpecialPageName can be found looking for canonical page name.

For example:

  • A numeronym like C10k is considered one word for proximity, but two words for matching.
  • pluralized numbers, like "2010s"

The following match the single term txt2regEx on a page: txt , 2 , regex , reg , ex , txt2 , 2reg , 2regex. None of those portions would match in a phrase search; only "txt2regex" would match.[8]

The following match the two terms 2 + 2 : 2 or "2" , 2 2 or "2 2" , "2 2" or "2" , "2+2" or 2+2 , "2-2" or 2-2 , "2.2" or 2.2 Each term is a query, and the grey-space is an AND.

Fuzzy search, wildcards, and stemming

Stemming is a way to match meaning "ambitiously", to get the numbers up, for possible semantic matching, such that run_shoe also matches running shoes. Stemming is a spelling algorithm only distantly reliant on any dictionary. [9] The algorithm attempts to find the same word, but in all its word endings.

A fuzzy search will match a different word. Words (but not phrases) accept approximate string matching or "fuzzy search". A tilde ~ character is appended for this "sounds like" search. The other word must differ by no more than two letters.

  • Not the first two letters. The first two letters must match.
  • Two letters swapped.
  • Two letters changed.
  • Two letters added, two letters subtracted, or one subtracted and one added.

But it can differ by one letter in these ways. A fuzzy search matches the word exactly plus words like it.

  • this~,→ thus and thud, thins and the, but not his or thistle
  • charlie~ parker~ → Charlie Parker and Charles Palmer and Charley Parks

With wildcards you can specify which letters change, including the first two letters, and you can increase the number of letters that can change. Wildcards have their own rules:

  • * zero or more letters or numbers
  • *? one or more letters or numbers.
  •  ? one letter or number
  • * can go at the beginning, middle or end.
  •  ? cannot match the first letter; it can go in the middle or the end.
  •  ? and * can be used any number of times in a word
  • this* → thistle and This1234 and This
  • g?it?r → gaiter goiter guitar g8it9r
  • key* → keypad and keypunch

While the word indexes are being built and updated, stemming automatically adds aliases to most entries. An actual dictionary is not used. Instead it runs an algorithm that applies generic English syntax rules for word endings. The results are imperfect.[10] Even misspelled words, non-words, and words with numbers in them are indexed and stemmed in this way. By adding different forms of the same word to the indexed search query, stemming is a standard method search engines use to aggressively garner more search results to then run a bunch of page-ranking rules against.

For example, stemming will alias cloud, clouds, clouded, and clouding. It will not alias the word cloudy, but it will alias the various forms of cloud to the non-word cloudion, because -ion is a common word ending.

Stemming is automatically turned off for insource searches:

To turn stemming off put the word in quotation marks, this is an "exact phrase" search.[11]

For example: gameFolks, game!folks, game:folks matches FolksSoul


  • Proximity searches do not search titles.
  • Proximity works backwards if you give it a higher count.
  • Proximity searches turn off stemming.

An "Exact phrase" or a word will match in a title. And creating a phrase "with tilde"~ just turns on stemming, (which is equivalent to forming a phrase by joining the words with_greyspace). But "exact phrase"~1 matches the wording in that order plus allows any one extra word to fall between the two words.

For example

  • "exact second phrase"~2 allows two extra words to fit anywhere on either side of the second term.
  • "exact phrase"~3 also finds "phrase exact" (the two words in reverse order)
  • Looking for either "Shift-Alt-P" or "Alt_Shift-P"? Its not "Alt-shift-P"~3. It's not "alt shift"~3-P. Use "alt shift p" OR "shift alt p" instead.
  • "Dorsal vertebrae"~2 matches "Dorsal (or Thoracic) vertebra"
  • "Three extra words"~5 matches "three w-1 w2% extra w:3 w_4 $w5 words".

"hitch4 hiker2" finds the two "words" in that order, (possibly separated by punctuation or brackets or other keyboard symbols like math symbols), and without the quotes finds them in the same article. In both cases the article is listed when the space satisfies the logical AND meaning.

hello_dolly does the same thing as "hello dolly" does, but the double quotes version offers a proximity filter. After the closing quote you add a tilde ~ and a number that indicates the total number of words allowed between all the terms.

Backward proximity works too, but includes the two end words between each segment. Proximity cannot make the last word proximate to the first. The proximity can be a large number, like 500 or 1000.

Say a page has word1 word2 word3 in that order.[12]

Two search terms with no quotes is two filters, and a bunch of page-ranking rules.

Search logic

Truth logic is AND, OR, and not.

  • Queries do not accept parentheses. So multiple terms cannot be grouped into a single, logical term.
  • Parameters do not accept AND or OR, but do accept not
  • word word2  will AND the two terms.
  • word AND word2  will AND the two terms. (similar)
  • word OR word2  will OR the two
  • -word will not the term, excluding the pages that match word.
  • !word will not the term (similarly)

Logical OR increases results, whereas logical AND decreases them. Logical not is a good way to refine a query by removing any kind of term except the prefix parameter.

For example while -refining -unwanted search results. For example credit card -"credit card" finds all articles with "card" and "credit"

Prefix and namespace

Prefix and namespace are the only positional parameters, and namespace is an unnamed search parameter. One or the other of them is used in a query to override the initial search domain set by user profile or by the search bar. They aren't used together: prefix overrides namespace.

The namespace argument must be at the beginning of a query, and the prefix: parameter must be at the end of a query.


Namespace: is an unnamed search parameter that goes at the beginning of a query.[13] The namespace is followed by a colon, followed by zero or more whitespace characters. and matches a namespace name. The namespace names and "all" work as expected, but seeing one in the search box does not guarantee it represent the search results, as explained below.

In addition to the usual namespace names and their aliases

  • all searches all namespaces on the wiki.[14]
  • file searches the wiki plus the Commons wiki.
    • the words and phrases on the file pages are searched
    • the textual content inside all uploaded attachments is searched[15]
    • If the match is made inside a pdf (or the like) this is indicated in the searches results parenthetically: "(matches file content)".
  • file:local turns off the search on Commons
  • all does not search Commons
  • The namespace names are not case sensitive, but "all" and "local" must be lowercase.
  • All: is not a search namespace, and will be treated as a word.
  • local: will not be treated like a word, but silently ignored instead, unless the File namespace is involved, such as it is on the search bar when activating Multimedia or Everything.
  • In a query, local: only has an effect following the File namespace file:local.

Pages with namespaces outnumber pages without them 7 to 1.

On the search bar at the search results page

  • Everything searches all, plus Commons and the File namespace.
  • Advanced when All (namespaces) is checked is equivalent to Everything.
  • Multimedia searches the File and Media namespaces on the local wiki plus Commons.

These differ from namespace "all" by matching your search terms inside a pdf on a help:file page, that item on the search results page says "(matches file content)".

For example file:"885.7 seconds" matches inside a pdf, but all:"885.7 seconds" does not.


prefix:namespace: string  filters a namespace down to one or more pages where string matches the pagename's beginning characters.[16] For example, prefix:help:t  finds Help pagenames that begin with "T".

  • When the string has zero characters all pages in the given namespace are found.
  • When the string has all the characters a pagename, a single page is found.
  • The string is not case sensitive.
  • The namespace can be an namespace alias, like WP for Wikipedia.
  • A space between the namespace and pagename is allowed.
  • The namespace for prefix defaults to article space.
  • Prefix will not match a redirect. (But see Special:PrefixIndex.)
  • Prefix cannot be used as a filter: the dash of -prefix is ignored. -prefix:WP: ab  only sets the search domain to "Wikipedia:Ab".
  • No pagename characters are ignored. Even the space character is part of the pagename, and this is why prefix must go at the end.

Prefix can perform the function of the namespace filter, plus it can isolate a single article whereas intitle cannot. Prefix cannot isolate a single page if it has subpages.

An alternative to a prefix query is Special:PrefixIndex:

  • multi-column report capable of listing several hundred pagenames on one page
  • Case sensitive
  • lists redirects too


Comparing the namespace and prefix parameters:

  • Prefix and namespace can both serve to set the initial search domain.
  • For a given namespace they are equivalent.
  • They both filter titles.
  • The both accept namespace aliases, but prefix does not recognize "all".
  • They both limit the initial search domain to one namespace.
  • A namespace goes only at the beginning, and a prefix goes only at the end.

The following methods set an initial search domain by namespace:

  • a prefix:, which defaults to article space
  • a namespace argument at the beginning of a query, which defaults to the user's default search domain
  • the URL parameters &nsN=1
  • the "advanced profile" GUI on the search results page

These are in the order of precedence. A prefix overrides a namespace overrides the GUI. The argument to the prefix parameter is a fullpagename, which conveys a namespace.

When alternating search domains, with the various techniques, and because of their priorities, it deserves repeating: check the search bar indication; it is most subtle. [17] The Advanced namespace selection pane from the search bar is not so subtle. It will remain for as long as the earlier selection "remember selection for future searches" is in effect. You can "remember" article space and then either 1) press Content, 2) choose another search bar search domain, or 3) remove all instances of &profile=advanced from the URL.

Page attributes

These five search parameters filter a namespace according to an input word or phrase.

  • No OR. For example, no intitle:A OR intitle:B
  • No positional requirements, and all can standalone, for example !hastemplate: Val
  • Only incategory accepts several inputs (between pipe | characters)
  • Only linksto and insource do not accept greyspace phrases
  • Only linksto is case sensitive.
  • Only insource is sensitive to an non-spaced colon:character.

These parameter names must be in all-lowercase letters.


Intitle finds a word or phrase in a pagename. Like a word or phrase search stemming and fuzzy searches can apply.

  • A word input can be put in double "quotes" to turn off stemming.
  • A phrase input can use greyspace to turn on stemming.
  • A single word input can suffix the tilde ~ character for a fuzzy search.
  • A single word input can suffix the tilde * character for a wildcard search.
  • Intitle does not search redirects.
  • Proximity search is not an option in a title search.

To find a match in a redirect title, or to apply a proximity search to a title you can rely on page ranking software to boost title matches before content matches. So a basic word or phrase search, or proximity search, is an alternative to intitle.

For example

intitle: "forest ridge" finds one, while the proximity search
"forest ridge"~3 finds a dozen related titles immediately.
intitle: image_label shows stemming while intitle: "image label" does not.
intitle:juggle shows stemming.
intitle:sun intitle:moon shows how to search for two words in one title.


Incategory has the general format

incategory: "category|category|...|category

and selects from the pages section of given category pages, those pages that are also in the search domain.

  • Incategory inputs are not case sensitive.
  • Incategory inputs are space sensitive. No spaces around the category. For any space inside any input, use "double quotes" around the whole expression.
  • The search results do not including subcategories. For that there is a deepcat search parameter, available by adding a line to your javaScript and CSS files.[18]
  • Multiple categories may be applied up to the 300-character limit of a query.

Because many pages outside the mainspace are also categorized, the counts often won't match the category unless the search domain is the entire wiki:

Multi-category input counts a page only once. The following two categories have 209 pages in article space, with six pages found in both categories:

incategory:"Information retrieval techniques" incategory:"Natural language processing" (6)
incategory: "Natural language processing" (159)
incategory: "Information retrieval techniques" (50)
incategory: "Information retrieval techniques|Natural language processing" (203:= 209−6)

On the other hand these are disparate categories:

Because of the nature of Wikipedia:categorization these categories share no pages:

Categories and Search are synergistic.

  • To search for category titles, and for links and text on a category page, search the category namespace (or use CategoryTree, or Categories for title searches).
  • If two categories are closely related but are not in a subset relation, then links between them can be included in the text of the category pages.
  • A word or phrase search can often precisely match incategory: it can match inside the categories box at the bottom of every page. When this occurs that search result will include a parenthetical flag "(Category pagename)".

In the following examples, note how the page description in the category namespace show category sizes instead of page sizes.

  • category: intitle: disambiguation (searches the category namespace for titles with that word.)
  • category: history Texan (searches the category namespace for those two words in the title or body of a category page)
  • anaxyrus (It's easy to spot the pages that need categorization, because they also don't have a redirect with that term.)


Hastemplate finds pages that transclude a given template. Finds template usage, not just a name pattern, because it will find all pages where the template content itself was used in any way. The results differ slightly depending on the alias you give.


  • given the canonical pagename (on the title line), it will find all aliases' (redirects') usage too, and it will find any subpage links to it from a parent template too.
  • given an alias (on the redirect's pagename) finds redirect's name pattern
  • is not case-sensitive
  • accepts a fullpagename to find template usage of templates (homed) in other than the default, Template namespace (just as within the {{template}} call itself)

If you don't find the searched template name on the wikitext of the page, it can mean either that you gave the canonical pagename but it found an alias, or that it was called as a secondary template by way of a template that is shown in the wikitext. To find visible (primary) calls only, use insource.


Insource: term   finds a word or phrase in wikitext.

  • No greyspace_phrases.
  • No stemming.
  • No proximity.
  • Yes wildcards, but only for words, not when the term is an "exact phrase".
  • treats a non-spaced colon : character like a normal letter
  • Insource doesn't search in .js or .css files except in comments or nowiki tags.

Unlike a normal search insource doesn't find things "sourced" by a transclusion.

Insource targets wikitext in two ways. They look similar, but the regexp form employs the slash / character to delimit the regexp.[19]

  1. insource: term   finds an indexed word or phrase.
  2. insource:/regexp/   targets the entire wikitext of every page in the search domain as one long string of characters per page, either having a pattern or not. This is the "regular expression" (or regexp, or regex). Its metacharacters can represent multiple possibilities for a character position or a range of character positions within a page, using metacharacters for truth logic, grouping, counting, and modifying the characters to be found.

A basic regexp is an easy way to find a specific, /"exact strings"/, as shown below. The double quotes are field delimiters. They are escape characters which quote all the set of characters between them, and keep their interpretation literal (keep any metacharacter interpretation from occurring).

An advanced regexp uses the metacharacters to program general string patterns. It finds everything, even pieces and parts of words, conveying no notion of "words", but only that of a string of characters in a sequence. Metacharacters are interpreted unless quoted by a backslash, double quotes, or square brackets. See the section on regex. The obvious example is, you must quote any slash in your pattern so it won't be interpreted as the closing slash delimiter, using \/ instead of / to match a literal slash. A regexp interprets all metacharacters. Testing a regexp pattern responsibly, requires limiting the search domain

  • by making it a single page using a page-name filter prefix:page name
  • a prefix parameter or other filter that limits the search domain to only as many pages as necessary
  • the test wiki.

Abusing regexp will not harm Wikipedia performance, but it limits regex search information from flowing elsewhere.

Only regex interpret greyspace characters. The regular insource, as everywhere else, ignores greyspace characters. So insource:"M S" matches m/s, as do insource:"M-S" and insource:"m=s". But insource:/M\/S/ will match it, and the filtered version will to: insource:"M/S" insource:/M\/S/. The insource:"word1 word2" filter is the most obvious filter for insource:/word1 word2/, where the two wikitext words are only separated by punctuation and space. Say the target string is {{Val|9999|ul=m/s|fmt=commas}}:

  • insource:"val 9999 ul m s fmt commas" → match
  • hastemplate: val insource:"9999 ul" → match
  • hastemplate: val insource:"999" → no match
  • hastemplate: val insource:"fmt commas" → match
  • hastemplate: val insource:"ul m" → match
  • hastemplate: val insource:"ul M S" → match
  • hastemplate: val insource:fmt → match

Insource matches words sequentially, but the match could occur anywhere on the page, not necessarily inside the {{template markup}}. For this there is {{template usage}}, and it matches any regex inside the template.

For thorough precision, use /regex/. For example, to find any bare URL inside <ref name=name>...</ref>, with [external link brackets label], with possible ref name=name you than can't use the simpler insource:"ref http server com". Taking a cautious approach, before trying the full regexp, create a search domain under 10,000 pages. Starting with two filters, prefix and insource:

  1. insource: "ref http" prefix:A 98000 is too many to start.
  2. insource: "ref http" prefix:AA 1000 is good.
  3. So ya try adding a regex term insource:/\<ref[^>]\> *\[?https?:\/\/[^][<> "]+\]? */ zero for prefix:AA, one for prefix:AB
  4. So ya try just insource:/\<ref[^>]\> instead, and then try prefix:AA zero; try AB, one.
  5. You notice you forgot the modifier for [^>]*.
  6. insource: "ref http" insource:/\<ref[^>]*\> prefix:AB. There are 3700, and that is OK.
  7. Experiment further. Then decide to do the project in segments AA, AB, AC, ... ZZ.
  8. insource:/\<ref[^>]*\> *\[?https?:\/\/[^][<> "]+\]? */ insource: ref prefix:AA

We have the only possible filter insource: ref prefix:AA. That filter produces a regex search domain of only 2300. The filter insource: ref prefix:A produces a search domain of 264000. Running the regex on that many pages is possible, and produces 64000 results.

To find a more targeted URL, say, use insource: "http yahoo brand edgar com"   (or cut and paste the entire URL, slashes dots, and all; it doesn't matter). Do another search with the https version. These searches capable of more flexibility than Special:LinkSearch. No filter is needed, but every search always benefits from extra information: any word, any phrase, and most parameters.


Linksto Reports wikilinks to a page name.

  • Linksto only accepts a canonical fullpagename. Use the title line. If the title does not begin with a capital letter, or if you're not sure about the title line for any reason, you can preview {{FULLPAGENAME}} on an edit of the page.
  • Linksto is case sensitive.
  • Namespace aliases are found, but not accepted as input.
  • Linksto does not find redirects. If you want all links to content you'll have to search each redirect page name.
  • Linksto does not report the given page as a link to itself, even when there are internal section-to-section links.
  • Linksto does not find URL-style wikilinks to a page.
  • Collapsed navlinks are not reported by linksto, but they are reported by WhatLinksHere.

Linksto reports wikilinks to a page name, even if the wikilink is

  • to a section.
  • from a subpage link.
  • hidden in a transclusion ("behind" a template that forms a wikilink).

Linksto can differ from the "What links here" tool, because the search domain for "What links here" is all. Linksto search results are in your default search domain. (Also linksto reports the count, as do all searches.)

In addtion to wikitext it searches inside a pages transcluded content.

first, and then scan the contents.[20] For example

linksto:"Mozart and scatology"

will report a list of 300 articles that link to it, as will "What links here". But Mozart and scatology is actually linked only 15 times by content authors. The rest are due to Mozart and scatology in Template:Wolfgang Amadeus Mozart on the unwanted pages. The template is wanted, but the "links to" reference is probably not.[21]

The trick to getting around this, and just finding all authorship links to an article is a regexp search:

: insource:"pagename"   insource:/\[\[ *[Pp]agename *[]|]/

That search will find articles only because the initial : limits the initial search domain to article space, no matter how your default search domain happens to be set. It will find all of the links many times more quickly than a bare regexp would, because the first insource term instantly creates the refined search domain that sets the proper limits for the regexp search. A regexp can accommodate for the variations found in the wikitext allowed by the permissions of wikilinks: 1) the metacharacter * allows for "zero or more" space characters before and after the title, and 2) the [character class] at the beginning allows for the relaxed capitalization of the first character in any pagename, and 3) the character class at the end finds the link whether it is labeled via the pipe character | or closed via the square bracket ] of the wikilink.

Links to transclusions are handled by hastemplate.

Sorting results

A page's overall score determines its place in the search results.

A better match will raise the score.

  • A section zero (lead-section) match is better than a numbered section.
  • A title or headings match is better than a lead section match.
  • A greater frequency of a search term is better.
  • A direct match is better than a stemmed match.
  • When several words are all found in many documents, a matching order is better.
  • A higher mesh—more links to and from a page—is better.

Wikiproject "importance" and article quality assessments can factor in. Searching from a page, its categories, wikidata, and geo-location can factor in.

Knowing this you may be able to better find, for example, a half-remembered title. Using intitle may skew the results too much because of the order of the words. Use those in a word search, and depend on page ranking. The titular words will show up on top.

To get an idea of how CirrusSearch might work see mw:Search/Old#Search_Weighting_Ideas.

To sort search results by date, use prefer-recent. To sort search results by by template usage, use boost-template.


The morelike search parameter lists all articles that compare in word frequency and word length to one or more given articles.

morelike: pagename | pagename2 | ... | pagename50
  • Quotation marks are not needed, and spacing is not important.
  • Capitalization is enforced, and misspelled pagenames silently fail.
  • Redirects are accepted; the target article's title is used.
  • a pagename with a namespace silently fails.
  • wp:shortcuts silently fail. (A shortcut redirect from article space to a project space.)
  • No other search parameters or other terms are allowed alongside morelike.

Morelike calculates a multi-word search.

: word1 word2 ... wordN

See them highlighted in the snippet.

Morelike looks up the given pagename(s) in the search index, creates a word-frequency aggregate and a word-length aggregate from all the words, and calculates a multi-word search based on those, plus internal, variable settings. It is an expensive search.

For example, say you search for

morelike:William H. Stewart

then pick a name from that list and add it

morelike:William H. Stewart|Leroy Edgar Burney

then add more names, until you have five input pagenames. Then you could begin blindly adjusting this automatically calculated morelike query, saying the following sorts of things: Make the calculated query

  • at least five words
  • a minimum word length of seven
  • a minimum word frequency of three
  • At most four of the five pagenames must have the term.
  • At least three of them must have the term.

Then, say, you adjust the number of input pagenames that have a word to two (out of five).

It can also find similar articles based on just the title, or on just the headings, or on just the lead section.

  • &cirrusMtlUseFields=yes&cirrusMltFields=title
  • &cirrusMtlUseFields=yes&cirrusMltFields=headings
  • &cirrusMtlUseFields=yes&cirrusMltFields=text
  • &cirrusMtlUseFields=yes&cirrusMltFields=auxiliary_text
  • &cirrusMtlUseFields=yes&cirrusMltFields=opening_text
  • &cirrusMtlUseFields=yes&cirrusMltFields=all

The search results depend on internal (Mlt, More like this) variables, settable via the URL, concerning which words to search with:

&cirrusMltMinDocFreq How many articles with a search word, minimally
&cirrusMltMaxDocFreq How many articles with a chosen word, maximumally
&cirrusMltMaxQueryTerms number of search words, maximum
&cirrusMltMinTermFreq Minimum word frequency of a chosen word.
&cirrusMltMinWordLength Minimal length of a term to be considered. Defaults to 0.
&cirrusMltMaxWordLength The maximum word length above which words will be ignored. Defaults to unbounded (0).
&cirrusMltFields A comma separated list of the fields to use. Allowed fields are title, text, auxiliary_text, opening_text, headings and all.
&cirrusMltUseFields (true or false) use only the field data. Defaults to false: the system will extract the content of the text field to build the query.
&cirrusMltPercentTermsToMatch The percentage of terms to match on. Defaults to 0.3 (30 percent).

For example here is what the address bar (turned search bar) looks like for a morelike search for lead sections of two articles, as compared to other lead sections: Notice the end containing the two added URL parameters that activated a morelike capability.


You can sort search results by date.

  • prefer-recent:
  • prefer-recent:recent,boost

It goes anywhere in the query. It defaults to 160 days as "recent", and applies its boost formula 60% of the score. The formula is not the usual multiplier, it is an exponential muliplier, potentially much more powerful. This enables it to work where the default for "recent", instead of being 160 days, is can be as little as 9 seconds. If your "recent" means 9 seconds, use prefer-recent:0.0001

For example, if you're only interested in the relatively few articles that have changed in the last week, use 7 instead. How this works is that all articles older than seven days are only boosted half as much, and all articles older than 14 days are boosted half as much again, and so on.

The boost is more than the usual multiplier, it is exponential. The factor used in the exponent is the time since the last edit. The bigger the time since the last edit, the less the boost. The formula is e-t, where t is either the interval in days or interval of interest. I don't know. ??

Add prefer-recent to the beginning of a search. It will give the more recently edited articles a boost in the search results. The general form is


This parameter accepts two, comma-separated arguments to allowing for adjusting the default settings. By default this will scale 60% of the score exponentially with the time since the last edit, with a half life of 160 days. So the default is prefer-recent:0.6,160.

This can be changed to increase the weight:


or decrease it:


The proportion_of_score_to_scale must be a number between 0 and 1 inclusive. The half_life_in_days must be greater than 0 but allows decimal points, and so works pretty well to sort close edit times if very small.

For example prefer-recent:0.6,0.0001 operates with a half-life of 8.64 seconds

This will eventually be on by default for Wikinews.


Boost-templates:" " adds weight to pages with the given template or templates (plural). Using this search parameter overrides the normal template-boosting function of Search. Don't use this search parameter without supplying the weight-boosting argument unless you mean to disable the template weighting function for the search.

The general format is

boost-templates:"Template:pagename|parameter Template:pagename|parameter"

You see, normally the system message[22] titled MediaWiki:cirrussearch-boost-templates boosts the score of the following fullpagenames: Template:Featured article|200% Template:Featured picture|200% Template:Featured_sound|200% Template:Featured_list|175% Template:Good_article|150%. These are the actual template names and there actual boost. These are replaced during the boost-templates usage.

For example a search for "phenom" AND "lecture", with the templates Search link and regexp having the weighting score of the pages they are on multiplied by 1.5 and 2.25 respectively, ignoring all other templates (halting the addition of any score for any other template):

phenom lecture boost-templates:"Template:search link|150% tlusage|225%"

Boost-templtes differs from hastemplate in

  • the default namespace
  • gramar. Boost-templates has a plural form, and uses a dash between the words.
  • syntax. Boost-templates requires quotation marks.
  • function. Hastemplate is a filter, but boost-templates is not; it only changes a score.
  • Boost-template has a parameter for controlling the boost.

If you just want your search results to include only pages with certain templates, use hastemplate one or more times instead, to filter out pages that don't. Otherwise, choose a multiplier similar to the system message shown above. Multiplying a page score by 10 is done with 1000%, and will probably mask all other weighting functions, such as "when the search words match in the title", will have little effect in the presentation of search results, and is not recommended because it affects the order of the entire list.

Either hastemplate or boost-templates one can go anywhere in the query, each having other terms on either side of it. is a term in a query that can go anywhere in the query, having other terms on either side of it.


Relevant issues in CirrusSearch:

  • T73123: pagename can't have double quotation " mark: incategory or intitle
  • The tilde ~ character should not affect the all parameter, for example ~all:hephalump. Not only does ~ at the beginning not navigate, but it also does not create a page, and all this without interfering with any namespace argument, but it does interfere with the pseudo-namespace "all".
  • T124272 Use of both AND and OR in the same query don't work as expected
  • A phrase search can extend over a number # sign, but not an asterisk * character. This is inconsistent.
  • T119806 cm2 does not find cm2, m3 does not find m3, where the superscript are unicode characters.
  • The search profile dialog box is difficult to dislodge. Even after the search profile is changed back to default, it continues to display.


  • Use AND between two phrases, for example "one two" AND "three four", to avoid six unwanted articles relating to the double quote " mark.


Regular expressions

Indexed search

First, all pages are scanned by the search engine. The entire wiki is treated as one "full text" kept in a separate database built just for search indexes. It's like the index in a book, but practically every word and every number is indexed to every page.[23]

Since each word in the prebuilt search index already points to the pages that contain it, most any word you search for, is actually a single record lookup in that index. (This is also true for phrases to a certain extent.)

There are separate indexes kept updated for the

  • titles
  • visual content
  • wikitext
  • templates

All the words each template outputs are indexed to the all pages onto which they are transcluded. In other words any text transcluded by a template is indexed to its target page. [24] An "index search" take basically no time to execute. They are cheap and plentiful.

Preparing and maintaining the search indexes is done in the background in near real time. As soon as you save the page, a few seconds later you can search for the changes you just made. For templates that are transcluded onto many many pages, the propagation of those changes to all the pages index entries might take a minute.

Indexes are based on alphanumeric characters; they store no information on non-alphanumeric characters. Although an indexed search can ask for punctuation, brackets, math and other symbolic characters of the keyboard, these are ignored without warning. Now you understand why search indexes are so fast.

Each regexp search needs an indexed search filter to provide them a search domain under 10000 pages.

Indexed search

A basic indexed search

  • searches only article space. That is the default.
  • matches only letters and numbers. This is usually not a problem.
  • works basically the same way for all public search engines. You can usually find the information you are looking for near the top of the search results by relying on page ranking software.
  • lands a lot of search results. You rely heavily on page ranking rules. You then refine search results based on the topmost pages. This is done with the not filter, signified by a minus sign attached to the front of the unwanted word to filter out page-hit noise you could not have predicted. This is the first thing you learn.
  • is an "aggressive matcher" including as many pages as it can by matching all forms of each word you enter.

Basically, why would anyone ever want to learn "how to search", since it is just key words, and these are obviously known?

An advanced index search

  • targets specific pages, instead of seeking general information.
  • doesn't need page ranking at all and cannot accept myriad results.
  • Cares about the quantity of page-hits shown on the right hand side of the search results page.

Regex search

A regex search actually scours each page in the search domain character-by character. By contrast, an indexed search actually queries a few records from a database separately maintained from the wiki database, and provides nearly instant results. So when using using an insource:// (a regexp of any kind), you should consider creating the other search terms that will limit the regex search domain as much as possible. There are many search terms that use an index and so instantly provide a more refined search domain for the /regexp/. In order of general effectiveness:

  • insource:"" with quotation marks, duplicating the regexp except without the slashes or escape characters, is ideal.
  • intitle, incategory, and linksto are excellent filters.
  • hastemplate: is a very good filter.
  • "word1 word2 word3", with or without the quotation marks, are good.
  • namespace: is an advanced filter, but practically useless for regex, except that it may enable a slow regexp search to complete a long life.

The prefix operator is especially useful with a {{FULLPAGENAME}} in a search template, a search link, or an input box, because it automatically searches any subdirectories. To develop a new regexp, or refine a complex regexp, use prefix:{{FULLPAGENAME}} on a page with a sample of the target data.

Search terms that do not increase the efficiency of a regexp search are the page-weighting operators: morelike, boost-template, and prefer-recent. The regex search main concern is to first limit the search domain with an indexed search employing filters, not such "search engine queries". Then it actually searches every page character by character. It examines each page of a narrowly defined search domain.

A basic regex search

  • can pattern any character string exactly using a regexp.
  • excludes as many pages as it can.
  • quotes each regexp in double quotes to turn off metacharacters.

An advanced regex search

  • uses metacharacters.
  • benefits by being developed in a sandbox.

The regexp can be a thousand words matching every character literally, or a few symbols of a regex metacharacter language, or any combination of the two. It can match any character from any keyboard.

Regex thus have the power to produce exactitude, but are slow (expensive), and come with the responsibility to add filters to increase speed (reduce costs).

Developing a regex search virtually always requires trial and error, an iterative development process supported by {{regex}} and {{template usage}}. The easiest filters to add are a namespace, or a prefix, or a copy of the regex without the slashes removed. Such filters all use an index to search, and by doing so are much faster. This is one of the first things we learn about regex searches: accompany them by filters.[25]

Search domain size

  • are voluntary, not automatic
  • protect accessibility to regex
  • sustain the open use of the most advanced search feature possible
  • help avoid an HTML timeout, which will kill a search
  • create {{regex}} developmental sandboxes
  • are considerate, taking only the processing power they need

Running a bare regex can't hurt Wikipedia:performance, but without applying basic search techniques to them, regex searches can limit other regex searchers, and become an issue of contention.

all: insource "question sublinks" How many pages on the wiki is that? OK. sublinks]]?"/

Search link
apostrophe   '
brackets [ ]  ( )  { }  ⟨ ⟩
colon :
comma ,  ،  
dash ‒  –  —  ―
ellipsis   ...  . . .
exclamation mark  !
full stop, period .
guillemets ‹ ›  « »
hyphen-minus -
question mark  ?
quotation marks ‘ ’  “ ”  ' '  " "
semicolon ;
slash, stroke, solidus /  
Word dividers
interpunct ·
General typography
ampersand &
asterisk *
at sign @
backslash \
caret ^
dagger † ‡
degree °
ditto mark
inverted exclamation mark ¡
inverted question mark ¿
number sign, pound, hash, octothorpe #
numero sign
obelus ÷
multiplication sign ×
ordinal indicator º ª
percent, per mil  % ‰
plus and minus + −
equals sign =
basis point
section sign §
tilde ~
underscore, understrike _
vertical bar, pipe, broken bar |    ¦
Intellectual property
copyright ©
sound-recording copyright
registered trademark ®
service mark
currency sign ¤

฿¢$ƒ£ ¥

Uncommon typography
index, fist
irony punctuation
In other scripts

This covers enough of the regular expressions to get started answering questions about wikitext contents on the wiki. Regex are about using meta characters to create patterns that match any literal characters. The pattern you give will match a target, character by character. To make some positions match with multiple possibilities, metacharacters are needed, and they are from the same keyboard characters that are also in the wikitext.


The left curly bracket is a metacharacter, and so the regexp pattern given must "escape" any opening curly bracket \{ in the target "{" intending to match a template in the wikitext. All target text (all wikitext) is literal text, but we can backslash "escape" the regex metacharacters \. \? \+ \* \| \{ \[ \] \( \) \" \\ \# \@ \< \~ when we refer to them as literal characters in the wikitext we are interested in mining. Search will ignore the backslash wherever it is meaningless or unnecessary: \n matches n, and so on. So although you don't need to backslash escape & or > or }, it is safe to do so. An unnecessary backslash will not cause your pattern to fail, but what will is using certain characters literally— [ ] . * + ? | { ( ) " \ # @ < ~ .

  • [0-9] will match any digit, [a-y] any lowercase letter except z, [zZ] any z, (and so on). So square brackets mean "character class".
  • Dot . will match a newline, or any character in the targeted position

The number of sequential digits or characters these symbols match is expressed by following it with a quantifying metacharacter:

  • * means zero or more
  • + means one or more
  • ? means zero or one

of the character it follows after. The number of times it matches can also be given in a range, a{2} a{2,} a{2,5} matches exactly 2, 2 or more, or 2-5 a's. So curly brackets mean "quantifier".

  • The parenthesis are a grouping mechanism, so we can quantify more than just the previous character, and so we can make boundaries for a set of alternative matches. (See alternation below.)
  • The quotation marks are an escape mechanism, like square brackets or the backslash.
  • The angle brackets stand for numerals, not digits. Say <5-799>, to match 5–799, in one to three positions. Compare this with the alternative: [0-9]{1,3} could match ones, tens, or thousands as, 0-999 or 00-999 or 000-999.
  • Tilde ~ looks ahead and negates the next character. In other words if the pattern matches in this position, then un-match it if the next character is ~character.

It is not safe to search for a lone @ because that single metacharacter matches literally everything; you can use \@ to find all pages that use an "at" symbol.

Similarly find all pages that use the number zero, Search returns an error to search for a lone 0; use one of the three escape mechanisms for 0 or @.

  • "0"
  • \0
  • [0]

or find a larger pattern around the zero you seek. Although zero is not a metacharacter, these escape mechanisms work.

The rest of wiki regex is pretty straightforward. Characters stand for themselves unless they are metacharacters. If they are metacharacters they are escaped if outside of a character class.

Character classes

A character class means "literal characters", plural. It means "literal", and so normally you don't have to escape a metacharacter character in a character class; they're already square-brackets escaped. The /slash delimiters/ mean we must of course escape any slash character, even inside a character class. No other character in a character class except slash always needs escaping; but because ] and - have special meaning (metacharacter) to a character class, they must be escaped sometimes: those two are also literal (escaped) metacharacters if they are the first character, but otherwise they must be also, like dash, be escaped: only backslash-escape works as the escape mechanism in a character class.

A character class can serve to escape metacharacters, so [-|*\/.{\]] or []|*\/.{\-] means "either a dash OR pipe OR star OR slash OR dot OR left curly bracket or a right square bracket". So [][.?+*|\/{}()\-]" or [-[.?+*|\/{}()\]]" works to find all the metacharacters in the wikitext, all of them except the backslash. Neither [\] nor [\\] allows us to OR a literal backslash. To OR a backslash character, there's alternation with the pattern \\ to handle that case. (See below.)

A character class understands the "inverse" of itself, [^abc] is "not a or b or c". A character class stands for a single character in a targeted position, so it's not really an inverse of a set, but rather a NOT of a character.

Currently character classes are limited to an expansion of four characters, so [0-9] would require three searches [0-3], [4-7], and [8-9]. The alphabet would require seven searches. This is to guarantee regex will work without overloading the search engine. See task T106685.

Note that constructs such as \d (digit) or \a (alphabetic), used in some other regex implementations, are not accepted.


Finally, alternation is a class of regex that contains alternative possibilities for a match, say an AA or a BB, or a CC:

  • "AA" OR "BB" OR "CC" to Word search an entire page
  • AA|BB|CC to regexp search a two-character position
  • (AA|BB|CC) where used within a larger regexp because an alternation finds the longest pattern, and so the parentheses define that boundary, but it's a boundary you don't have to make if an alternation is the entire regexp pattern.=== Developing regular expressions in an ad hoc sandbox ===

Regular expressions are little computer programs, so it is characteristic of regex searches that they must be written while studying the target data, and tested to achieve there potential precision and thoroughness. But only a few of these intensive searches are technically able to run at a time against the database.[26] A sandbox minimizes your footprint, and guarantees that you will never run an untested regexp on every namespace in the wiki, even if your default search would let you do that.

Although a normal search targeting the entire wiki run quickly, a regexp search should target as few pages as possible by using filters in order to run quickly. A filter is part or whole of a database query. Filters include

  • word(s) or phrase
  • intitle:
  • incategory:
  • hastemplate:
  • prefix: (always at the end)
  • linksto:
  • namespace: (always at the beginning)
  • insource:"word1 word2"
  • insource:word

Order is not important because the search is optimized by the software before it is run.

To target just one page while experimenting with or developing a regex search, target a fullpagename. From the search box use the filter prefix:fullpagename. From the edit box (of any section of the page with the target data), you can always just write prefix:{{FULLPAGENAME}} and it will "expand" for you to the fullpagename. Although you can edit a history page, technically a "history page" is not a page (in the database), and so {{FULLPAGENAME}} there will point to the database version (not its own rendering). For the same reason, you cannot search for the wikitext on a page that is not already saved (to the database), although you can certainly change the search parameters again and again with no need to save them.

Fullpagename is namespace:pagename. Knowing this you can adjust your Prefix parameter. Although prefix can filter down to one page, it can filter up to a namespace, and it also accepts the beginning letter(s) of set of pagenames if you want to reduce the namespace search domain.

Regex sandboxing uses an ad hoc sandbox made by editing any page containing the target data, and using it as a "sandbox" (not editing it to save it). It then develops by using adding a search link that includes insource:/regexp/, with the filter prefix:{{FULLPAGENAME}} alongside.

Use of a sandbox enables the smallest possible footprint by using filters to limit the search domain. Once your regexp pattern is honed, you increase the search domain. A regex search is best run with filters, not alone even if it is a polished rexexp.

Sandboxing procedure

Rather than use the search box, where entering an equals sign and a pipe character, and "quotes around phrases" is a straightforward matter, it is still easiest to use a regex-based search-link template — {{regex}} or {{tlusage}} — on the page with sample data, because then you can focus on the target data there and on writing the regexp pattern. It is easier, that is, if you already understand how templates "escape" the pipe character and the equals sign. See Help:Template#Parameters for other important details.

The procedure here is an iterative, read-evaluate-modify cycle. Regex development requires that you study the target data while writing and rewriting its pattern.

  1. Navigate to a page with the wikitext instances you are interested in mining. Or create one yourself, and save it to the database so the query will find it.
  2. Open the wikitext, and enter a {{regex}} or {{tlusage}}.
  3. Show preview, and activate the search link. On the search results page, note the bold text in each match.
  4. Go back in your browser. Modify the regexp, and cycle until done. (Or don't go back, you may want to modify the query at the search box.)
  5. Expand the search domain, and test the accuracy of those results. You can trim or expand the number of the results using prefix:.

Caveat emptor: if you change the target for an immediate retesting, you'll have to save and purge, but not if you just change the regexp.


As an ad hoc sandbox, you can show the wikitext of a section like this, (already saved in the database), modify some of the patterns in the regex-search-link template calls on this page, do a Show Preview, and see what matches when you click on the newly formed regex search-link, all quite safely, and without changing a thing in the database.

The template calls that produce "ft/s, 2 sq ft, 3 m/s, 4 m*s-2, 5 ft.s-2, 6 °C/J, and J/C" appear in the wikitext of this section like this:

  1. {{val|1|ul=ft/s|fmt = commas}}
  2. {{val|2|u=ft2}}
  3. {{val|3|u=m/s| fmt =commas }}
  4. {{val|4|u=m*s-2}}
  5. {{val|5|u=ft.s-2}}
  6. {{val|6|u=C/J}}
  7. {{val|7|ul=J/C}}

Note how the above targets are |numbered|, then click on the links below.

Query Search link Answer
Q1 Using {{search link}}, does this page employ template Val ? {{sl|hastemplate: Val}}hastemplate: Val A. No, because this pagename is in Help not Article space.(Search link default). 1300 search results.
Q2 Using {{search link}} responsibly, does this page use Val's fmt parameter? {{sl|insource:/\{[Vv]al\{{!}}[^}]*fmt/ prefix:{{FULLPAGENAME}}}}

insource:/\{[Vv]al\|[^}]*fmt/ prefix:Template:Search link

A2.1. Look for 1 and 3 in the search results in bold text. (Adds an appropriate filter.)
Using {{regex}} instead... {{slre|\{[Vv]al\{{!}}[^}]*fmt}}

insource:/\{[Vv]al\|[^}]*fmt/ prefix:Template:Search link

A2.2 Less typing than {{search link}}.
Using {{template usage}} instead... {{tlre|Val|pattern=fmt}}

Testing fmt on this page

A2.3 Easiest for templates.
Q3. Who uses u=ft OR ul=ft? (one-letter differs) {{regex|ul?=ft}}

insource:/ul?=ft/ prefix:Template:Search link

A. Look for 1, 2, and 5 in bold text.
Using {{template usage}}... {{tlre|val|pattern = ul?=ft}}

Testing ul?=ft on this page

Finds same pattern, but only inside a Val template.
Q4. AND of these, who also uses fmt=commas after that? {{slre|ul?=ft.*commas}}

insource:/regexp/ prefix:Template:Search link

A. No context shown, but article title is shown. A half a Bug?
Who has one space before the word "commas"? {{slre|. commas}}insource:/. commas/ prefix:Template:Search link A. 1 but not 2.
Q5. Who uses either u or ul with "ft" OR uses "fmt=commas". {{slre|(ul? *= *ft{{!}}fmt *= *commas)}}

insource:/regexp/ prefix:Template:Search link

A. 1, 2, 3, and 5. (The pattern matches all possible spacing.)
Q6. Who uses ft or m, in |u= or |ul=? {{slre|ul? *{{=}} *(ft{{!}}m)}}

insource:/ul? *= *(ft|m)/ prefix:Template:Search link

A. 1, 2, 3, 4, and 5.

Used {{!}} for the alternation metacharacter. Used {{=}}. (Could have used named 1 = or nicely named pattern = .)

Q7. Who uses . or * in the unit code? {{tlre|val|pattern = u *= *(\.{{!}}\*)/}}

Testing u *= *(\.|\*)/ on this page

A. 4 and 5.
Who uses a pipe? {{regex|\|}}insource:/\/ prefix:Template:Search link All of them
Q8. Who uses / or - within the |u= or |ul= paramter? {{tlre|val|ul? *= *[^{{!}}}]+(\/{{!}}-)}}

Testing ul? *= *[^|}]+(\/|-) on this page

A. 1,3,4,5,6 and 7.
Q9. Where is Val used in the template namespace for numbers only, (no u, ul, up, or upl parameters). {{tlre|val|pattern = ~(u[lp].)|prefix = 10}}

hastemplate:"val" insource:/\{\{ *[Vv]al *\|[^}]*~(u[lp].)/ prefix:Template:

A. In the 30 or so templates listed.
Q10. Which articles use {{Convert}}'s and(-) option? {{tlre|convert|pattern=and\(-\)| prefix=0}}

hastemplate:"convert" insource:/\{\{ *[Cc]onvert *\|[^}]*and\(-\)/ prefix::

A Coast Range Arc and Skipjack shad

In Q2, notice how the MediaWiki software ignores the spaces around parameters, but how in Q4 the same MediaWiki software processes the spaces inside parameters. Q2 might have been solved with a plain insource:val fmt search because "fmt" and "val" are whole words, and fmt is rarely seen apart from inside Val. How about hastemplate:val insource:fmt?


  1. ^ Ssome users' default search domain is all namespaces. In cases like the bare regex search, the search engine protects itself by limiting all regex searches. A bare regex that crawls through millions of pages can take over twenty seconds, and may even cost you an HTML timeout. During that time very few other regex searches are allowed. Always use a filter with regex.
  2. ^ Searching for an equals sign requires using a regexp. As with any template, use {{=}} or |1= to pass in an equals sign to any parameter, even the link label.
  3. ^ Advancing editors who begin to search for Wikipedia's other pages may at times set their default search domain (at Special:Search Advanced) to all. Setting search to all is the most likely scenario to "set and forget". Since that includes article space, the usual results are comparable.
  4. ^ Unlike other data that score a page ranking, word frequency and location data can be kept updated in the index at all times. For each word on the wiki, the index stores a list of page names where that word can be found. Along with page name, the word's locations and count are also stored. Apache Lucene is the indexer, and it maintains the data; it uses the term frequency algorithm. For how it does this, see TFIDF Similarity.
  5. ^ Unlike for search indexes, page-ranking data is not immediately updated. When the number of incoming links has changed more than 20%, then it is updated.
  6. ^ {{search link}} always produces fully specified queries, even if no namespaces is given, because it defaults to article space.
  7. ^ A phrase will extend over whitespace unless it contains a bullet. A phrase can extend over an ordered list item, but not an unordered list item. In other words it can extend over a number # sign, but not an asterisk * character. The asterisk has special meaning to the analyzer. It is used to make an item in an unordered list, plus it is used as a modifier in search.
  8. ^ See the ElasticSearch "tokenizer" that CirrusSearch developed.
  9. ^ Stemming, like page ranking, is just a computer algorithm, and prone to needing occasional adjustments.
  10. ^ CirrusSearch uses kstem for the stemmer package, per T56022.
  11. ^ You can equally well use the insource parameter to turn stemming off. Also, please note that T113838 details this related bug: when stemming is turned off for a word the pages listed in the search results are correct, (they don't have stemmed-only variants, they all have the word as given) but any stems in the snipped are, incorrectly, highlighted.
  12. ^ This can't be proven in an example search of this page, but it will work on another page not containing this example. This because the match, showing in bold as proof here, prefers the proper order. It can be proved by put the target text on another page, then changing the query (on the search results page) initiate here to that page.
  13. ^ The search namespace matches in the first parameter of a query. This is consistent with its usage in navigation, wikilinking, transclusion, and page naming, where it is always the first word in the field.
  14. ^ To see all namespaces go to the search results page and click on Advanced. The default namespace shows in parenthesis.
  15. ^ The full text of every word on the wiki plus every word in every uploaded attachment, is all indexed together in a search database. CirrusSearch can parse and index thousands of formats.
  16. ^ Characters not allowed in pagenames are # < > [ ] | { }.
  17. ^ Always check the search bar for its indication. Activating the Advanced pane can show the default search domain, and the search box is very obvious with a namespace or prefix term. One way to do this is to click on the search bar search domain instead of clicking on the search button. The only time this does not work is when changing search domains in the Advanced tab: after you change them you must press Search, not Advanced.
  18. ^ To get deepcat as a search parameter install a gadget which automatically produces incategory:pagename1|pagename2|...|pagename70. To see the number of subcategories to see if there was more or less than 69, either go fwd and bwd in the browser history, or see the source HTML of the search results page, the <title> attribute
  19. ^ In computing it is common to delimit a /regular expression/ with slashes.
  20. ^ The search is not actually done page by page, but the index for the wiki is built page by page in this way.
  21. ^ By doing things like adding a Mozart navigation template to each page about Mozart [[wp:wikignomes|]] shore up the wiki infrastructure. Authorship, on the other hand, writes the prose of a page, one page at a time. (You cannot remove the unwanted links with -hastemplate:"Wolfgang Amadeus Mozart".
  22. ^ A system message is the value of a MediaWiki operations variable. It can consist of a snippet of plain text, wiki text, CSS, or Javascript. A message is used to customize the behavior of MediaWiki, especially as pertains to the user interface as seen by readers, but also including the way it itself appears as a simple message, and these for each language and locale.
  23. ^ When you search you are not scanning pages, you are looking up an entry in an index (a database). All content is at all times "known" and resides in indexes. So when you read "searches namespace" or "searches transcluded content on a page", you can mentally replace "search" with "searches the index for".
  24. ^ This is also said "the template on a page is expanded before the search of a page is done", but that is just an abstraction.
  25. ^ Because there are 28,754,264 users, and a well-filtered regex search only takes milliseconds, while a bare, wiki-wide regex can take tens of seconds, the benefits of adding a filter are enormous.
  26. ^ See how searches can kill Wikipedia's CirrusSearch/ElasticSearch engine

See also

Templates to search Wikipedia

Search links

A search link stores a query in a link that takes you to live search results for that stored search. They're found on user pages and talk pages and are used to create ad hoc search links from a preview. The plain wikilink [[Special:Search/query]] works just like the search box, so it will navigate to a page instead of providing the desired search results page that a search link always provides.

A search link is made by a template that outputs a URL instead of a wikilink. A template can specialize, save typing, hide implementation, and add value to existing Search features. A URL brings a useful set of additional features to search links. Besides being universal and uniform, a URL can call up other search processing and pass parameters. For example it can call other search engines to search Wikipedia. Also template programmers can use a URL to bring arcane or beta features to normal users. For example there are many URL-only tweaks offered for the morelike operator of CirrusSearch.

  • {{search link}} – create a search in a shareable link. Pick one or more namespaces, else it defaults to article space; pick a link title.
{{search link|tosa diary -"tosa diary"|"tosa" and "diary", but not "tosa diary"}}
"tosa" and "diary", but not "tosa diary".
  • {{Regex}} - develop a general regexp search.
{{regexp|\<--.*-->|label = Articles with hidden comments in the wikitext |prefix=0 }}
Articles with comments missing the bang ! in their syntax.
  • {{tlusage}} - develop a template regexp search, and pinpoint specific template-call details.
{{tlusage|Convert|\{{!}}C\{{!}}F|0|Articles that convert Celsius to Farenheight}}
Articles that convert Celsius to Farenheight
  • {{shortSearch}} - create three search links: Wikipedia and Google, plus create another link that's purely-Google.
{{shortSearch|system operations research}}
  • {{wpsearch}} – creates five search links: Wikipedia, Google, Bing, DuckDuckGo, and Yahoo
{{wpsearch|collaborative search}}
global warmingWikipedia search | Google search | Bing search | DuckDuckGo search | Yahoo search

Search boxes

Search boxes are made by <inputbox> tags. See mw:Extension:InputBox.

Page title searches

  • {{in title}} – Search for pages whose name contains given words
  • {{look from}} – Search for pages whose name begins with a given word

For searches with exact matches, exact in upper and lower cases, or in punctuation marks, see Help:Searching#grep.

Other Wikipedia editor helper