gojq

gojq is a portable Go command-line tool for jq-style JSON queries, with a library for embedding those queries in Go applications. It is best suited to developers who want JSON and YAML handling in a Go-based workflow. Its main appeal is the combination of a free CLI and configurable library; its main caveat is that jq compatibility has meaningful limits.

Overview

The CLI filters JSON, selects fields, makes updates, and accepts multiple input values. YAML input and output extend it to workflows that cross between the two formats. Because gojq is implemented in Go, it is designed to be portable and can be installed through Homebrew, mise, Zero Install, source builds, or Docker images.

That portability does not make it a drop-in replacement for every jq script. gojq does not preserve object key order, so it has neither keys_unsorted nor the --sort-keys option. It also differs on numeric extensions, regular-expression syntax, and other jq functions and flags. Scripts that rely on those behaviors need a compatibility check before switching.

Key features

Querying and number handling

Queries use jq-style syntax for filtering, field selection, and updates. Arbitrary-precision integer calculations cover addition, subtraction, multiplication, modulo, and divisible division, which helps when these operations need to preserve large integer values. That precision has a boundary: mathematical functions such as floor and round convert integers to floating-point numbers. gojq also rejects jq's NaN, Infinity, and leading-zero number extensions.

YAML support

YAML input and output are useful when data needs to move through a JSON-query workflow without first being confined to JSON. This makes gojq more versatile for format conversion and inspection than a JSON-only command would be, while its jq compatibility gaps still apply to the query language.

Embedding in Go

Go applications can parse and run queries, compile a query for reuse, and provide custom functions and iterators. That is a substantial advantage for products that need query behavior inside their own Go code rather than as a separate command. The library expects arrays as []any and maps as map[string]any, so callers must provide inputs in those forms.

Library access to OS environment variables is off by default for security and can be enabled with a configured environment loader. Module loading is also disabled by default and requires a module loader to be configured. Queries can produce infinitely many values or run without producing output, so applications should use RunWithContext to limit execution time.

Pricing

gojq is free at free. The free plan includes the MIT-licensed open-source software, CLI, and Go library. There is no paid tier or trial to weigh against it; the practical trade-off is the engineering effort of checking jq compatibility and, for library use, configuring loaders and managing query execution.

Platforms

gojq supports Linux, macOS, Windows, and self-hosted use. Its Go implementation is intended to be portable, and installation routes include package managers, source builds, and Docker images, giving developers several ways to fit it into command-line or server-side setups.

Who it's for

gojq is a strong fit for Go developers embedding jq-style queries in an application, especially when reusable compiled queries or custom functions and iterators are useful. It also suits command-line users who want free JSON querying with YAML input and output across the supported platforms. Teams with scripts that depend on exact jq behavior should first check the unsupported functions, flags, numeric extensions, key-order behavior, and regular-expression differences.

Pros and cons

Pros

• Free, MIT-licensed CLI and library make it accessible for both direct use and Go integration.
• YAML input and output support workflows that span JSON and YAML.
• Arbitrary precision for core integer arithmetic avoids fixed-width limits in the covered operations.
• Compiled queries, custom functions, and iterators give Go applications ways to tailor query execution.
• Environment access and module loading are disabled by default in the library, giving callers control over whether to enable them.

Cons

• It does not preserve object key order and lacks keys_unsorted and --sort-keys, which rules it out for workflows requiring those behaviors.
• Some jq syntax, functions, and flags are unsupported or differ, including NaN, Infinity, leading-zero numbers, and some regular expressions.
• Integer precision is not consistent across all math functions; floor and round convert integers to floating point.
• Embedded queries may run indefinitely or emit endless values, so applications need execution limits.

Alternatives

jq is the direct alternative for users who want the original standalone tool and its binaries for Linux, macOS, and Windows; gojq is the choice when a Go library or YAML support matters.

Dadroit JSON Viewer suits readers who want a graphical JSON viewer with CSV or XML conversion and can work within its 50 MB file cap for free non-commercial use; its Standard plan is $98 per y.

BracketView fits users looking for a browser-accessible JSON service with a free plan that caps uploads at 5 MB and includes limited encrypted snapshots, AI actions, and webhook requests.

gron is a free alternative for users who prioritize a command-line binary with no runtime dependencies across Linux, Mac, Windows, and FreeBSD.

jaq is another free option for users who want an open-source command-line program and Rust library.

jless is a free MIT-licensed command-line tool for macOS and Linux.

jidoujisho is a free option for Android users.

JSON Crack is a free, open-source online tool for readers who prefer a browser extension or web interface and can work within its approximate 300 KB data capacity, which depends on data complexity and hardware.

Browse more options in JSON Tools.

Verdict

Choose gojq if you want a free, portable jq-style CLI with YAML support or need to embed configurable queries in a Go application. Its library controls and arbitrary-precision integer operations are compelling for Go-centered workflows. Look elsewhere when exact jq compatibility is essential, or when a library integration cannot accommodate the required input types and execution limits.