Google Search Operators: What They Are and How to Actually Use Them

Quick answer: A search operator is a special command you add to a search query to narrow what comes back. Type site:example.com pricing and Google only returns pages from example.com that mention pricing. Operators turn a general web search into a scoped query against a specific site, file type, title, or URL pattern, and they work both in the search box and programmatically through a search API.

I use maybe eight operators regularly. This post covers those eight, the recipes I actually reach for, and how to run operator queries in code, because that's where they get genuinely powerful.

The Operators Worth Knowing

Google supports a long tail of operators, many half-broken or deprecated. Here are the ones that reliably work and earn their place:

Operator	What it does	Example
`site:`	Only results from a domain or path	`site:docs.python.org asyncio`
`"exact phrase"`	Results must contain this exact phrase	`"connection reset by peer"`
`-term`	Exclude results containing a term	`jaguar -car -football`
`intitle:`	Term must appear in the page title	`intitle:changelog`
`inurl:`	Term must appear in the URL	`inurl:careers`
`filetype:`	Only files of this type	`filetype:pdf annual report`
`OR`	Match either term (must be uppercase)	`pricing OR plans`
`*`	Wildcard inside a quoted phrase	`"the * of programming"`

Operators combine freely, and combining is where the leverage is. site:example.com intitle:pricing -inurl:blog is a very specific question that would be tedious to answer any other way.

A few honest caveats. Google treats operator-heavy queries as a bot signal, so hammering them manually can trigger CAPTCHAs. site: results are not a complete index of a domain, so don't use the result count as a page inventory. And some old favorites like +term and link: are dead; anything a listicle from 2015 promises should be tested before you rely on it.

Practical Recipes

Operators become useful when you stop thinking of them as syntax and start thinking of them as questions. These are the ones I run most:

Find where a competitor talks about a topic.

site:competitor.com "rate limiting"

Search only documentation, excluding the marketing site.

site:docs.stripe.com webhooks

Find guest post or contributor opportunities.

intitle:"write for us" SaaS

Locate public PDFs and reports on a topic.

filetype:pdf "state of devops" 2026

Check what a site says about you, minus your own domain.

"link.sc" -site:link.sc

Find duplicate or scraped copies of your content.

"a distinctive sentence from your article" -site:yoursite.com

Scope a search to a URL structure, like only job pages or only changelogs:

inurl:changelog "breaking changes" 2026

The pattern in all of these: you're not searching the web, you're querying a slice of it. That mental shift is the whole trick.

Operators for Scoped Research

Where operators really shine is research workflows, whether the researcher is you or an LLM agent.

Say you're evaluating how five competitors handle SSO. The naive approach is searching "competitor SSO" five times and wading through results. The scoped approach is site:competitor.com (SSO OR SAML OR "single sign-on") per competitor, which jumps you straight to their docs and pricing pages.

The same applies to content gap analysis. site:yoursite.com "kubernetes operators" returning nothing while the same query on a competitor returns twelve results is a finding, and it took ten seconds.

For AI agents, operators matter even more. An agent doing research burns tokens and time on irrelevant results; a scoped query returns a smaller, denser result set. If you're building agents that search, I'd argue teaching them site: and exact-phrase quoting is one of the cheapest quality upgrades available. More on that pattern in the best search API for AI agents.

Using Operators Programmatically

Everything above works in a search API. Operators are just part of the query string, so a scoped search through link.sc looks like this:

curl https://api.link.sc/v1/search \
  -H "x-api-key: lsc_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "site:news.ycombinator.com \"web scraping\" legal",
    "engine": "google"
  }'

This matters for two reasons. First, running operator-heavy queries by hand in a browser gets you CAPTCHA-walled fast; Google is suspicious of exactly the kind of queries that are most useful. Going through a search API sidesteps that entirely, which I covered in how to avoid Google blocking automated searches.

Second, code lets you run an operator template across a list. Here's the competitor topic scan as a script:

import requests

API_KEY = "lsc_your_api_key"
competitors = ["competitor-a.com", "competitor-b.com", "competitor-c.com"]
topic = '"single sign-on" OR SAML'

for domain in competitors:
    resp = requests.post(
        "https://api.link.sc/v1/search",
        headers={"x-api-key": API_KEY},
        json={"q": f"site:{domain} ({topic})", "engine": "google"},
    )
    results = resp.json()["serpData"]["results"][:5]
    print(f"\n{domain}: {len(results)} pages")
    for r in results:
        print(f"  - {r['title']}: {r['targetUrl']}")

Each result gives you a title, description, and target URL. When you need the actual page text, one follow-up call to the fetch endpoint per URL returns it as markdown:

page = requests.post(
    "https://api.link.sc/v1/fetch",
    headers={"x-api-key": API_KEY},
    json={"url": r["targetUrl"], "format": "markdown"},
).json()["content"]

For an LLM pipeline, that means two API calls get you from "scoped question" to "context ready to reason over."

Operators That Don't Work Anymore

Worth listing so you don't waste time debugging them:

link: for finding backlinks, dead for years
+term for forcing inclusion, retired; use quotes instead
~term for synonyms, retired; Google does this by default
info: and cache:, both removed

If you need backlink data, that requires a dedicated index, not an operator. And related: still technically exists but returns results so thin it's rarely worth typing.

The Takeaway

Search operators are the difference between asking the web a vague question and asking it a precise one. Learn site:, exact quotes, -exclude, intitle:, and filetype:, combine them, and move the queries you repeat into code. The link.sc docs cover the search endpoint if you want to script them, and the free tier is plenty for experimenting.

Want to run scoped, operator-powered searches from code without CAPTCHAs? Sign up for link.sc and get 500 free credits a month.