Query Syntax

Code Search uses the Zoekt query language for powerful code searching. This guide covers everything from basic searches to advanced query techniques.

Basics

Everything is Regex

All queries in Zoekt are parsed as regular expressions using Go’s regexp syntax. This means queries containing regex special characters must escape them to match literally.

Caution

Special characters like ., *, +, ?, (, ), [, ], {, }, |, ^, $, and \ have regex meaning. Escape them with \ to match literally, or wrap in quotes.

For example:

• foo.bar matches fooxbar (. matches any character)
• foo\.bar or "foo.bar" matches literally foo.bar

Expressions

A query consists of one or more expressions separated by spaces. Each expression is treated as a pattern to match.

Query	Meaning
foo	Match the regex /foo/
foo bar	Match both /foo/ AND /bar/ in the same file
"foo bar"	Match the literal string foo bar (space included)
foo\ bar	Same as above (escaped space)

Note

Single quotes have no special meaning. 'foo bar' is two expressions: /'foo/ and /bar'/.

Boolean Logic

Implicit AND

By default, multiple expressions are combined with AND logic. A file must contain matches for all expressions to appear in results.

foo bar baz

Returns files containing ALL of: /foo/, /bar/, and /baz/.

OR Operator

Use or to combine expressions disjunctively:

foo or bar

Returns files containing /foo/ OR /bar/ (or both).

Tip

To search for the literal word “or”, wrap it in quotes: foo "or" bar searches for three terms.

Grouping with Parentheses

Group expressions to create complex logic:

foo (bar or baz)

Returns files with /foo/ AND (either /bar/ OR /baz/).

Groupings can be nested:

(foo or bar) (baz or qux)

Negation

Prefix an expression with - to exclude matches:

foo -bar

Returns files with /foo/ that do NOT contain /bar/.

Negation works with groups:

foo -(bar or baz)

Excludes files with either /bar/ or /baz/.

foo -(bar baz)

Excludes files with BOTH /bar/ and /baz/.

Field Expressions

Field prefixes restrict where a pattern matches. Without a field prefix, patterns match both file names and content.

Search Fields

Field	Alias	Description	Example
file:	f:	Match file names only	file:README
content:	c:	Match file contents only	content:TODO
repo:	r:	Filter by repository name	repo:linux
branch:	b:	Filter by branch name	branch:main
lang:	l:	Filter by programming language	lang:go
sym:	-	Match symbol definitions (ctags)	sym:main

Examples

file:README

Matches files with “README” in their name.

content:TODO

Matches “TODO” only in file contents (not file names).

repo:myorg/api lang:go func.*Handler

Search for func.*Handler in Go files within the myorg/api repository.

-f:test assert

Match /assert/ but exclude files with “test” in their name.

Repository Filters

Field	Values	Description	Example
archived:	yes, no	Filter archived repos	archived:no
fork:	yes, no	Filter forked repos	fork:no
public:	yes, no	Filter public/private repos	public:yes

archived:no fork:no readme

Search for “readme” in non-archived, non-forked repositories.

Case Sensitivity

The case: modifier controls case matching:

Value	Behavior
case:auto	Case-sensitive if pattern has uppercase (default)
case:yes	Always case-sensitive
case:no	Always case-insensitive

FOO case:yes

Matches only FOO, not foo or Foo.

TEST case:no

Matches TEST, test, Test, etc.

Note

In auto mode, MyFunction is case-sensitive (has uppercase), while myfunction is case-insensitive.

Result Type

Control what kind of results are returned:

Value	Description
type:filematch	File content matches (default)
type:filename	Only matching filenames
type:repo	Only repository names

type:repo config

Returns repository names matching “config” instead of file matches.

Text Values

Field values can be plain text, quoted strings, or regex:

Plain Text

repo:myproject
lang:typescript

Quoted Strings

Use double quotes for values with spaces or special characters:

file:"my file.txt"
content:"foo bar"
repo:"my org/my project"

Regular Expressions

Use forward slashes for regex patterns:

content:/func\s+\w+\(/
file:/.*\.test\.ts$/
repo:/github\.com\/myorg\/.*/

Escape Characters

Escape special characters with backslash:

content:"foo\"bar"
file:my\ file.txt

Language Support

The lang: field filters by programming language as detected by go-enry (based on linguist):

Popular Languages

Language	Also matches
lang:go	Go
lang:python	Python
lang:javascript	JavaScript
lang:typescript	TypeScript
lang:java	Java
lang:rust	Rust
lang:c	C
lang:cpp or lang:c++	C++

More Languages

Language	Also matches
lang:ruby	Ruby
lang:php	PHP
lang:swift	Swift
lang:kotlin	Kotlin
lang:scala	Scala
lang:shell or lang:bash	Shell scripts
lang:yaml	YAML
lang:json	JSON

Tip

Language names are case-insensitive: lang:Go, lang:GO, and lang:go all work.

Common Patterns

Find Function Definitions

Go

lang:go func\s+\w+\(

Python

lang:python def\s+\w+\(

JavaScript/TypeScript

lang:typescript function\s+\w+\(

Find Import Statements

Go

lang:go ^import\s

Python

lang:python ^(from|import)\s

JavaScript/TypeScript

lang:typescript ^import\s

Find TODOs and FIXMEs

(TODO|FIXME|HACK|XXX):

Find Configuration Files

file:(config|settings)\.(json|yaml|yml|toml)$

Exclude Test Files

myfunction -file:test -file:spec -file:mock

Search Specific Repository

repo:myorg/myrepo lang:go error handling

Advanced Examples

API Endpoints

Search for HTTP handlers in Go:

lang:go func.*Handler repo:api

Security Audit

Find potential SQL injection:

(exec|query).*\+.*\$ lang:go

Dead Code

Find unused exports:

sym:deprecated -file:test

Dependency Check

Find package imports:

lang:go "github.com/pkg/errors"

More Examples

Find error handling in Go, excluding tests:

lang:go (err != nil) -file:_test\.go

Search multiple repos for a pattern:

(repo:frontend or repo:backend) auth

Find README files in non-archived repos:

type:filename README archived:no

Case-sensitive class name search:

lang:java class MyService case:yes

Find files modified in feature branches:

branch:/feature-.*/ config

Quick Reference

Operators

Operator	Example	Description
(space)	foo bar	AND (both required)
or	foo or bar	OR (either match)
-	-foo	NOT (exclude)
()	(a or b) c	Grouping
""	"foo bar"	Literal string
//	/foo.*/	Regex pattern

Fields Summary

Field	Alias	Values	Description
file:	f:	text/regex	File name filter
content:	c:	text/regex	Content only filter
repo:	r:	text/regex	Repository filter
branch:	b:	text/regex	Branch filter
lang:	l:	language name	Language filter
sym:	-	text/regex	Symbol definitions
case:	-	yes/no/auto	Case sensitivity
type:	t:	filematch/filename/repo	Result type
archived:	a:	yes/no	Archived repos
fork:	-	yes/no	Forked repos
public:	-	yes/no	Public repos

Tips

1. Start Simple: Begin with basic patterns and add filters as needed
2. Use Quotes: When searching for phrases or special characters
3. Leverage Regex: For complex pattern matching
4. Filter Early: Add repo: or lang: to narrow results quickly
5. Exclude Noise: Use -file:test to skip test files
6. Check Case: Use case:auto (default) for smart matching