Self-hosted service
turbot/steampipe avatar
turbot/steampipe

Two install lines, one of which pipes curl into sudo

Zero-ETL, infinite possibilities. Live query APIs, code & more with SQL. No DB required.

8,008 stars348 forksGoAGPL-3.0

At a glance

What is it?
Steampipe turns cloud and SaaS APIs into SQL tables through plugins that map them to database tables, and the same plugin can be used four ways: through the bundled Postgres, through native Postgres foreign data wrappers, through SQLite extensions, or through standalone exporter binaries that need no database. The code is AGPL 3.0, Turbot distributes its own build under commercial terms, and contributors must sign a CLA.
Who is it for?
Take Steampipe when you want to query cloud and SaaS APIs with SQL across more than 2000 documented tables and you want the same plugin to work in a terminal, in Postgres and in SQLite. Leave it if you need to run inside a network where plugins cannot be installed, because every query path goes through a plugin you add separately.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • turbot/steampipe8,008 ★ · +46
Star history
Repository2026-09-222026-11-15
turbot/steampipe8k8k

46 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

AGPL 3.0 code, commercial terms for Turbot's build, and a CLA

The licence section is three sentences and each one changes the picture.

The repository is published under the AGPL 3.0. Steampipe is a product produced from this open source software, exclusively by Turbot HQ, and it is distributed under their commercial terms. Others are allowed to make their own distribution of the software, but cannot use any of the Turbot trademarks, cloud services, or similar.

So the code you read is copyleft, and the binary Turbot ships is a commercial product built from it. That is a common shape for an infrastructure tool with a hosted companion, and it means two separate questions for a user: what may I do with the code, and may I call my build Steampipe.

Then there is the contributor side: contributors must sign Turbot's Contributor License Agreement as part of their first pull request. So an AGPL repository with a corporate CLA, which is a combination that will end a conversation at some companies before the code is even discussed.

Support runs through a Slack channel named steampipe.

The same plugin works four ways, and only one of them needs Postgres

The distributions section is the part that makes Steampipe more than a CLI, and it is five items.

The Steampipe CLI runs queries that translate APIs into tables in the Postgres instance bundled with Steampipe. So the database exists, you just do not install it.

The Steampipe Postgres FDWs path uses native Postgres Foreign Data Wrappers to translate APIs into foreign tables, which means you point your own Postgres at it instead of using the bundled one.

The Steampipe SQLite extensions path uses SQLite extensions to translate APIs into SQLite virtual tables, which is the route for a single-file or embedded application with no server at all.

The Steampipe export tools are standalone binaries that export data from APIs with no database required, which is the one for a scheduled job that writes files.

And Turbot Pipes runs Steampipe in the cloud, where a Pipes workspace also brings in Powerpipe for visualising query results and Flowpipe for automating workflow.

So the plugin is the unit of work and the distribution is the unit of deployment, and the same plugin can be a table in four different places. That is why a team can prototype in the CLI, promote the same queries into a foreign table, and later export the same data without rewriting anything.

Two install lines, one of which pipes a script into sudo

Installation is two commands, one per platform, and the second one deserves a second look.

On macOS:

sh
brew install turbot/tap/steampipe

On Linux, or Windows under WSL2:

sh
sudo /bin/sh -c "$(curl -fsSL https://steampipe.io/install/steampipe.sh)"

That second line fetches a script over HTTPS and executes it as root in one step. It is the standard shape for a convenience installer and it means the trust decision is about the TLS chain and Turbot's domain rather than about reviewing the code first. A source build is documented as well, in the Developing section: clone the repository, cd into it, run make, and the binary lands in /usr/local/bin unless you set OUTPUT_DIR.

Plugins come after the binary, one at a time:

sh
steampipe plugin install hackernews

which is what separates the CLI from the plugins. The README lists available plugins for AWS, Azure, GCP, GitHub, Kubernetes, Hacker News and others, and says there are more than 2000 tables in all, each documented with copy, paste and run examples.

The Makefile stamps 0.0.0-dev-<branch>.<timestamp> into the binary

There is no version file. The version is produced at link time.

make
OUTPUT_DIR?=/usr/local/bin

and the build itself is:

make
	go build -o $(OUTPUT_DIR) -ldflags "-X main.version=0.0.0-dev-$(GIT_BRANCH).$(TIMESTAMP)" .

Two shell evaluations feed that string. TIMESTAMP is a date and time stamp, and GIT_BRANCH comes from the current git branch, run through two sed passes: one replaces slashes and underscores with hyphens, the other strips anything that is not a letter, digit, dot or hyphen.

So a binary built from a feature branch reports its own branch name, which is exactly what you want when you have six of them on a developer's machine and no way to tell them apart by hand.

The all target is different in an instructive way. It first builds pkg/pluginmanager_service and ui/dashboard as separate make invocations, then does the same go build. So the plugin manager and the dashboard are built before the main binary, and the top-level Makefile is a coordinator rather than a compiler recipe.

hashicorp/go-plugin is in the require block, which explains the architecture

One dependency answers the question of how a plugin talks to the CLI.

go
	github.com/hashicorp/go-plugin v1.7.0
	github.com/hashicorp/hcl/v2 v2.24.0
	github.com/spf13/viper v1.20.1

hashicorp/go-plugin is the RPC framework for launching a plugin as a separate process and talking to it over a network connection rather than a function call. The README itself does not describe how plugins are run.

The other two entries are configuration libraries: hcl/v2 is HashiCorp Configuration Language, and viper is a configuration layer.

Around them the rest of the list is a terminal application: chroma for syntax highlighting the SQL you type, go-pretty and tablewriter for the tables that come back, ansicolor and fatih/color, a spinner, isatty to know whether you are on a terminal, cobra and pflag for the command line, pgx for the Postgres connection, and go-git.

The build-from-source docs still print steampipe version 0.22.0

One detail in the Developing section has not kept up with the releases, and it is the kind of thing that sends a new contributor down an hour of pointless debugging.

The check-the-version step shows:

sh
steampipe --version
steampipe version 0.22.0

The three newest release tags are v2.4.9 from 2026-11-01, v2.4.8 from 2026-10-22 and v2.4.7 from 2026-09-16. So the documented output is from a 0.x line well before the current 2.x releases, and a contributor who builds from source today will not see 0.22.0.

That is also consistent with how the version is produced. Because the Makefile injects a 0.0.0-dev string derived from the branch, a source build never reports a release number at all unless you are on a tag. The stale 0.22.0 line reads like an output captured once and pasted in, which it almost certainly is.

The rest of the Developing section is in better shape. Cloning with git, building with make, installing a plugin and running a query are each in their own step, and the query example uses the .inspect meta command, which lists the tables a plugin exposes, including steampipe_registry_plugin and steampipe_registry_plugin_version.

The default branch is develop, and the Go directive is 1.26.7

Two metadata facts that decide what you can build.

The default branch is develop, not main. That is worth knowing before you script anything against this repository.

The module declaration is:

go
module github.com/turbot/steampipe/v2

go 1.26.10

Two things in three lines. The path carries a v2 major suffix, so the import path for a consumer is github.com/turbot/steampipe/v2 even though the binary is called steampipe.

And the go directive carries a patch version, 1.26.10, rather than the usual 1.26. In a module this is normally a language floor, so it declares a specific patch of the toolchain rather than a minimum minor release, which is a stricter requirement than it looks and can catch a contributor out on a slightly older Go.

There is also a replace block, and the interesting entry is not the one that is active:

go
replace (
	github.com/c-bata/go-prompt => github.com/turbot/go-prompt v0.2.6-steampipe.0.0.20221028122246-eb118ec58d50

The interactive query prompt is a fork maintained by Turbot, pinned to a commit hash rather than a tag. The two commented-out lines below it point pipe-fittings and the plugin SDK at local paths, which is the shape of a dependency you develop against rather than consume.

Editorial conclusion

Take Steampipe when you want to query cloud and SaaS APIs with SQL across more than 2000 documented tables and you want the same plugin to work in a terminal, in Postgres and in SQLite. Leave it if you need to run inside a network where plugins cannot be installed, because every query path goes through a plugin you add separately. Verify three things. Read the licence section before you redistribute anything, because the repository is AGPL 3.0 while Turbot's own distribution carries commercial terms and the Turbot trademarks cannot be reused. Decide which of the four distributions you are actually using, since the CLI bundles Postgres, the foreign data wrapper path does not, and the export tools need no database at all. And check which branch you build from, because the default branch is develop and the Makefile stamps a branch name and timestamp into the binary rather than reading a version file.

Frequently asked questions

What is a steampipe?

Steampipe is described as the zero-ETL way to query APIs and services, exposing data sources to SQL. Plugins map APIs to database tables, the community suite has more than 2000 tables in total, and the whole thing ships as a single binary you can run locally or in a CI/CD pipeline.

How does a steampipe work?

Through plugins that map an API to database tables. You install one, for example steampipe plugin install hackernews, then query it as SQL with steampipe query followed by select * from hackernews_new limit 10. The same plugin can back a table in the bundled Postgres, a native Postgres foreign table, or a SQLite virtual table.

How do I install Steampipe?

Two lines. On macOS, brew install turbot/tap/steampipe. On Linux or Windows under WSL2, sudo /bin/sh -c "$(curl -fsSL https://steampipe.io/install/steampipe.sh)". Both are documented next to a downloads page, and plugins are installed separately afterwards with steampipe plugin install.

how to use steampipe

Install a plugin for the service you want, then start the interactive query shell with steampipe query and type SQL at the prompt. The CLI translates the API into tables in the Postgres instance bundled with Steampipe, several data sources can be queried in parallel, and a .inspect meta command lists the tables a plugin exposes.

is steampipe open source

The repository is published under the AGPL 3.0, and Steampipe is described as a product produced from that open source software exclusively by Turbot HQ, distributed under their commercial terms. Others may make their own distribution but cannot use the Turbot trademarks or cloud services, and contributors must sign a Contributor License Agreement with their first pull request.

what is steampipe aws

AWS is one of the plugin targets. The README lists plugins for AWS, Azure, GCP, Kubernetes, GitHub, Microsoft 365 and Salesforce among others, hosted on the plugin registry, and steampipe plugin install takes a plugin name. Hacker News is the example used in the quick start.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. turbot/steampipe on GitHub
Community

Where developers are discussing it

Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.

Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/turbot-steampipe.svg)](https://hysenlabs.com/projects/turbot-steampipe)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/turbot-steampipe.svg)](https://hysenlabs.com/projects/turbot-steampipe)

Was this useful?