# Getting Started with the GTM CLI

> Query ZoomInfo's go-to-market data from your terminal. Install the GTM CLI, sign in with one browser command, and pipe companies, contacts, intent, and research into jq, CSV, or your data pipeline. Plus when to reach for the CLI over MCP or the API.

**Date:** 2026-06-22  
**Source:** https://gtm.ai/guides/gtm-ai-cli-getting-started

---

The GTM CLI puts ZoomInfo's go-to-market data behind a single command: `gtm`. Search and enrich companies and contacts, pull intent signals and news, run agentic account research, then stream the results out as JSON, CSV, or a table. It talks to the same hosted endpoint as the ZoomInfo MCP server, so the data, the auth, and your GTM context match exactly what Claude or Codex see. What changes is where the work runs. The CLI runs in your shell.

This guide covers when to reach for the CLI, how to install it and sign in, and the handful of commands worth running first.

## CLI, MCP, or API: which one

ZoomInfo exposes the same data three ways, through one backend. Pick the door by where the work happens.

Reach for the **CLI** when you live in the terminal and want data you can script. It is deterministic, no model sits in the loop, and every result pipes cleanly into `jq`, a CSV, a cron job, or a shell loop. Installing it and signing in takes under a minute, which also makes it the quickest way to confirm your access before you build anything larger.

Reach for **MCP** when an agent should hold the data. Claude, Codex, Cursor, and ChatGPT call the same tools through the [hosted MCP server](/docs/mcp), and the skills layer turns those tools into finished briefs and lists. That is the path for conversational research and for letting a model decide what to fetch.

Reach for the **API** when you are writing an application. You get raw HTTP, your own retry and caching logic, and credentials that run as a service account. The [Start Building](/start-building) page has the quickstart.

A rough rule: terminal and scripts go to the CLI, agents go to MCP, applications go to the API.

## Install

Homebrew is the shortest path on macOS and Linux:

```shell
brew install zoominfo/gtm-ai/gtm-ai-cli
```

On Windows, or anywhere you would rather use Node, install the global npm package:

```shell
npm install -g @zoominfo/gtm-ai-cli
```

Prebuilt binaries for macOS, Linux, and Windows live on the [releases page](https://github.com/Zoominfo/gtm-ai-cli/releases) if you want to skip a package manager. Confirm whichever route you took:

```shell
gtm --version
```

## Sign in

Authentication is OAuth in your browser. There is no client ID or secret to paste:

```shell
gtm auth login
```

The command opens your browser, you sign in to ZoomInfo (SSO included), and the token is saved to `~/.config/gtm-ai/` at mode `0600`. Check your status any time:

```shell
gtm auth whoami
```

The data commands need a ZoomInfo subscription with bulk data credits. Search and lookup are free. Enrichment and research draw down credits, and the [CLI reference](/docs/cli) spells out what each one costs.

## Your first query

Find software companies in San Francisco and print them as a table:

```shell
gtm companies search --industry software --metro "CA - San Francisco" --employees "100to249" -f table
```

One detail saves you a 422. ZoomInfo's search filters expect canonical values, not free text, so look the value up first and pass what it returns:

```shell
gtm lookup --field industries --fuzzy software -f table
gtm lookup --field metro-regions --fuzzy "san francisco" -f table
```

`gtm lookup` covers industries, metro regions, management levels, intent topics, tech vendors, and the rest of the controlled vocabularies. Run it once, keep the IDs, move on.

## Pipe it anywhere

The reason to use a CLI is the pipe. Every command emits structured output (`-f json`, `jsonl`, `csv`, `yaml`, or `table`), so each result becomes the input to whatever runs next.

Pull a single column with `jq`:

```shell
gtm companies search --industry software --metro "CA - San Francisco" | jq '.data[].attributes.name'
```

Export a contact list straight to CSV:

```shell
gtm contacts search --management-level "VP Level Exec" --department Sales --company-id 344589814 -f csv > vp-sales.csv
```

Chain two commands: search for the top accounts, then enrich each one.

```shell
gtm companies search --industry software --metro "CA - San Francisco" --page-size 3 -f json \
  | jq -r '.data[].id' \
  | xargs -I{} gtm companies enrich --id {}
```

That pattern (search for IDs, enrich for detail) is the backbone of most CLI workflows.

## The command surface

The full toolset sits behind `gtm`. Use `companies` and `contacts` to search, enrich, and find lookalikes; `contacts` also returns AI-ranked recommendations for any account. Pull buyer signals with `intent`. Track funding, hiring, M&A, and other business events with `scoops`, then read categorized articles for a known company with `news`. Print your org's offerings, ICPs, personas, and competitors, free of charge, with `gtm-context`.

Two commands earn a closer look. `gtm research account` runs the same multi-step research an agent would, then hands back a brief instead of raw rows:

```shell
gtm research account --company-id 344589814 \
  --query "Prep for a renewal call: relationship, recent news, and open risks"
```

And `gtm raw` reaches any tool that does not have a dedicated wrapper yet:

```shell
gtm raw list-tools -f table
gtm raw call search_intent --args '{"topics":["Cloud Applications"],"signalScoreMin":80}'
```

## What's next

The [CLI reference](/docs/cli) documents every command, flag, and output format. Want the same data inside an agent? Connect the [MCP server](/docs/mcp), or install the [Claude Code plugin](/guides/how-to-connect-to-zoominfo-mcp-in-claude-code) to get the tools and the GTM skills together. When a search rejects a filter, `gtm lookup` has the value you need.