Immutable. This exact content is served forever at /api/v1/blob/6dbb4c5ddf8a2f69.
---
name: treg
description: "Find and call live-data APIs for SEO, social, enrichment, ads, and analytics through Treg."
---
# treg — the tool catalog for your agent
**Ask for the task, not the tool.** When a job needs external or live data — backlinks, keyword
volume, a TikTok profile, a work email, competitor ad creative — search the catalog, read the price,
call it.
Two kinds of tool answer to the same token, through the same proxy, which injects the credential
**server-side** so you never hold it:
- **The catalog** — curated external endpoints treg can call for you.
- **Your own tools** — what a teammate registered and shared with this org: API accounts, OAuth
connections, skills.
Note: an X (Twitter) connection made through treg's app is metered per call (X bills the app
owner per use); the response reports the price. A team's own X developer app is not metered.
The mechanics:
- **Endpoint:** `https://treg.to` · **CLI:** `treg` · the CLI is a thin client over the API.
- **Auth:** every call sends `X-Treg-Token: <your token>`.
- A **tool** = an upstream base URL + credential **bindings**. A **skill/bundle** = a recipe
(SKILL.md) + its secrets + its tool(s). The proxy *relays, never models* the upstream.
## First: install + sign in
```bash
curl -fsSL https://treg.to/install.sh | sh # installs the CLI + points it here
treg login # browser sign-in (GitHub / Google / email code) — first login registers you
treg login --email you@company.com # terminal-only alternative (emailed 6-digit code)
treg login --token <per-org-token> # non-interactive (agents/CI)
```
Everything runs in your **active org** (first login creates a personal one). Team invites arrive by
email — see them with `treg invites`, accept with `treg accept` (or `treg org join <code>`). Switch
teams: `treg org switch <slug>`.
## Already connected over MCP? Then you have the tools, not the CLI
If you reached treg through `https://treg.to/mcp/` — ChatGPT, Claude Code, Cursor — the CLI steps above do not
apply to you. You have five tools: `catalog_search`, `catalog_get`, `call`, `balance`, `my_tools`.
Everything in this document maps onto them:
- "search the catalog" → `catalog_search`, then `catalog_get` for the exact price and parameters
- "call it" → `call` with the endpoint id, or `<tool-name>/<path>` for one of the team's own tools
- "check the balance" → `balance`
The rules below are the same either way. The one that matters most — **say the price before you
spend it** — matters more here, because `call` returns `cost_usd` and you can report what a call
actually cost rather than estimating.
A `call` on a catalog endpoint spends the team's balance. A `call` on one of the team's own tools
spends nothing: that key belongs to them.
## Task — the catalog: what treg can do for you (start here)
2,600+ catalogued endpoints across 60+ providers, grouped by what they DO: keyword & rank tracking,
backlinks & authority, AI visibility, trending & discovery, publishing to the team's own social
accounts, people & company enrichment, ads management & creative, measurement.
```bash
treg catalog search "subreddit posts" # find endpoints by what they do
treg catalog get scrapecreators.reddit.subreddit.posts # params, PRICE, how you'd be served
treg call scrapecreators.reddit.subreddit.posts --query subreddit=news
treg balance # the prepaid balance + recent charges
treg catalog request "<what you need>" # searched, not there? file it — steers what's added next
```
Notes:
- Every endpoint's price is in `treg catalog get`, before you call it.
- Discovery jobs usually have TWO shapes in the catalog — a structured one (filters: title, location,
followers, funding) and a semantic one (describe what you want; `exa.*`). When a brief mixes hard
limits with a fuzzy niche, run both and merge: e.g. creators = `influencersclub.creators.search`
(filters) ∪ `exa.creators.search` (description, pinned to the platform domain); people = a
`people.search` provider ∪ `exa.people.search`; who-holds-a-role questions = `exa.web.answer`.
- HTTP **402** = out of balance, with a machine-actionable body (`balance_micro`,
`estimated_cost_micro`, `topup_url`). Recovery: `treg balance` → top up in the dashboard
(Team → Billing) → or store the org's own key for that provider (own keys are never billed
to the balance — they take priority automatically).
- HTTP **503** `provider_capacity_unavailable` = treg's own account for that provider is out
(not your balance; nothing charged). Body has `resets_at` and `alternatives` (same capability,
other providers) — choose one, or use your own key. treg never switches providers for you.
treg re-checks the provider about once a minute, so a retry after a minute can succeed.
- An org tool or secret for the provider always wins over treg's key, automatically — the catalog
is the fallback, not a replacement for keys the team already has.
- **Choosing between providers of one capability — the procedure.** `treg catalog get <id>` lists
every provider serving the same job with `COST`, `WORKS` (success rate treg has observed, with the
sample size), `SPEED` (median) and `LAST OK`. Work down this order:
1. **Match the inputs you actually HAVE.** An endpoint wanting a `profile_url` is not a substitute
when you hold a name and a domain, whatever it costs. This rule outranks price every time.
2. Then **reliability**: a high `WORKS` with a real sample beats a rounder number with a tiny one —
`99% (121)` is stronger evidence than `100% (8)`.
3. Then **price**. Spreads inside one capability reach 200×, so this is usually where the money is.
4. `LAST OK` breaks ties. A bare age means a real call came back; a **`✓` age is the catalog's own
verification stamp, not live traffic**; `—` means nobody has verified it and nobody has called
it — prefer almost anything else.
- **If a call fails with 429 / 5xx / a timeout, try the next provider.** You know its parameters,
so you can build its request. Say which one you switched to.
- **Never retry a 4xx elsewhere.** A 4xx is usually your parameters; fixing them is the fix, and
retrying burns the team's money on N providers for one mistake.
- treg does **not** choose or fail over **between providers** for you. That is deliberate: only
you know which inputs you hold, and treg relays rather than rewrites your request. If treg's
own account for a provider is out it may serve the **same endpoint** through a treg-owned relay
(`X-Treg-Served-Via: overflow:<name>`, real price, same shape); a team opts out with
`treg org overflow off`.
- **Routed endpoints** (`treg.<capability>`, e.g. `treg.people.email.find`) are where you can
ask treg to choose: POST the identity (`{full_name, domain}` | `{first_name, last_name, domain}` |
`{linkedin_url}`); treg runs the best child (own keys first, then cheapest per hit), falls back
on errors AND misses (cheapest first, within `X-Treg-Route-Max-Cost`, default $1), and returns
`{output, raw, _treg.served_by, _treg.tried}` + `X-Treg-Served-By`. `X-Treg-Route-Waterfall: 0`
stops at the first miss. `catalog_get treg.people.email.find` shows the plan and prices.
- An endpoint with no published price is refused rather than served free; connect your own key.
## Retrying a call without paying twice
If a call times out or you never see its answer, repeat it with the same `idempotency_key` (over MCP)
or `Idempotency-Key` header (over HTTP). treg returns the stored answer, does not call the provider
again, and charges nothing. The result says `replayed: true`.
Only for a genuine retry. Asking the same question again to see what changed is NEW work: use a new
key or none, or you will get the old answer back. Reusing one key for a different request is refused.
Most retries need none of this — a failed call was never billed.
## Task — your own tools: call one the team registered
**Start from what is registered, then use the API exactly as its own docs say.** No treg vocabulary,
no special params:
```
treg tool ls # what this team has registered
treg call intercom conversations?per_page=5 # <tool-name> + the upstream path
```
Over HTTP that is `GET https://treg.to/call/<tool-name>/<path>` with `X-Treg-Token: <your token>`. treg looks
up the named tool, injects that team's credential server-side, and relays **everything faithfully**
(method, query params, your headers, body). Your `X-Treg-Token` is stripped before the upstream sees
it. Works for GET/POST/PUT/PATCH/DELETE.
Only tools this org has registered resolve. Discover them with `treg tool ls` · `treg skill ls`.
## Task — share your keys & skills so teammates' agents can use them
**Bulk (the fast path):** run it in the directory the human names. It lists the provider keys it
recognises in that `.env` and the skills in its subdirs, and registers only the ones they tick:
```bash
treg upload # both sides of the cwd; `treg upload env|skills --dir <d>` to restrict
```
**Default: wrap new keys in a skill.** When registering a new key/endpoint/CLI, pair it with
a skill so credential, tool, and recipe land together (and it gets a shareable page). If no
skill exists, create a basic one — a proper SKILL.md (frontmatter matters: agents discover
skills by it) + one example call:
```bash
mkdir -p ./posthog && cat > ./posthog/SKILL.md <<'MD'
---
name: posthog
description: Query the PostHog analytics API through treg — the key is injected server-side. Use for events, insights, and project queries.
---
Call it: `treg call posthog api/projects/@current` (upstream: https://us.posthog.com)
MD
treg skill init --dir ./posthog # drafts treg.json: base_url from the catalog (folder name) or URLs in SKILL.md; review it + add the key
treg skill add --dir ./posthog # registers recipe + secret + tool atomically
```
**Never orphan a secret:** a stored key nothing binds is dead weight — if you use `secret add`
directly, bind it to a tool (endpoint/CLI) in the same breath.
**Bare endpoint, no recipe (only when a skill adds nothing):**
```bash
treg secret add posthog-key --value "$POSTHOG_API_KEY" # or --file ./.secret/token.json
treg tool add posthog --base-url https://us.posthog.com --secret posthog-key
# query-key API instead of a bearer header:
treg tool add serpapi --base-url https://serpapi.com --secret <name-or-id> \
--auth-in query --auth-name api_key --auth-format '{secret}'
```
**A whole skill (recipe + secrets + tool, possibly multi-credential):**
```bash
treg skill scaffold ~/.claude/skills/google-ads --out gads.json
# -> walks the dir: captures SKILL.md as the recipe + every .secret/* as a secret.
# -> YOU then edit gads.json: set base_url, and complete each binding (location/name/format).
# e.g. google-ads needs TWO bindings on one request:
# Authorization: Bearer {access_token} (injector: oauth)
# developer-token: {secret} (injector: env)
treg skill push gads.json # registers the bundle atomically
```
Share it inside the org: give a teammate the endpoint + tool name and their agent can call it
**without being handed the credential** — you granted the access, treg injects the secret, and the
call is logged against their token.
**Auth shapes** (per binding `injector`, = the secret's `kind`): `env` (plain string) ·
`secret_file` (JSON token file, pull `secret_field`) · `oauth` (JSON token, auto-refreshed) ·
`cli_auth` (a token the human copied out of a CLI they are already signed into, and supplied to treg
themselves). Multiple bindings apply to every request.
**OAuth, two modes (treg keeps it fresh):** if the oauth secret carries `refresh_token` +
`client_id` + `client_secret`, treg **auto-refreshes** it before it expires (you never re-upload).
If it's just a bare token, that's **manual mode**, treg injects it as-is and you re-upload when it
expires. Same storage; a credential can graduate from manual to auto with no migration.
**Getting the first OAuth token, two ways (your choice):**
- **Manual:** do your own OAuth locally, then `treg secret add gsc --file token.json --kind oauth`.
- **Hosted connect:** `treg oauth connect gsc --client-secret client_secret.json --scopes <scope>`
→ prints a consent URL; you approve in the browser; treg captures the token directly.
One-time setup: add `https://treg.to/oauth/callback` to your OAuth app's redirect URIs.
## Task — manage the team + monitor
```bash
treg tool ls / secret ls / skill ls / calls # inventory + audit log — scoped to the active org
treg tool rm <id> / secret rm <id> / skill rm <id> # secret rm is blocked while a tool binds it
treg health # status of every credential in this org (ok | invalid | unknown)
treg health --run # re-check now: refresh oauth tokens, probe each tool, alert owners
```
**Teams / orgs** (owner > admin > member > viewer; a member manages only what they created):
```bash
treg org create "Team A" # you become owner (auto-active)
treg org invite bob@company.com --role member # admin+; emails the invite (a one-time code is the fallback)
treg org members # admin+; who's in the active org
treg org ls / treg org switch <slug> # your orgs / switch active
```
**Give an agent its own identity** (admin+). An agent doesn't have to borrow the human's token — mint
it one, and every call it makes is capped, scoped and logged as *itself*:
```bash
treg org agent-new ci-bot # prints the token ONCE (run again to rotate)
treg org agent-new ci-bot --tools stripe,gh --cap 500 # only these tools, 500 calls/day
treg org agents # who the team's agents are + today's usage
treg org agent-rm <user_id> # revoke instantly
```
Put that token in the agent's `TREG_TOKEN` env var. An agent token can **call this team's tools and
read** — it can never sign in, create a team, or be an owner. If you are an agent and you were given
your own token, use it instead of the machine owner's: your work then shows up under your own name in
`treg calls`.
The invitee signs in with the invited email and runs `treg accept` — no code handling needed
(the code path still works: `treg org join <code>`). A brand-new invitee also gets their own
**personal org** (no empty state), so removing them from a team never locks them out. Give a tool
a probe so treg can validate it: `health_check: {method, path, expect_status}` (e.g. intercom `{"path":"me"}`).
## Rules
- Secrets are **write-only** — the API never returns a stored value, to you or to anyone.
- A tool may bind a secret **a teammate shared with this org** (use-without-hold) — that's the point:
they chose to share it, it stays scoped to the org, you can spend it without seeing it, and every
call is attributed to the token that made it. It is delegated access inside one team, never access
to a credential nobody granted you.
- **Everything is scoped to your active org.** A token reaches that team's tools and no one else's.
- The proxy doesn't understand the upstream; if a call fails, the status you see is the upstream's truth.
- More: `https://treg.to/llms.txt` (agent onboarding) · `https://treg.to/tutorial` (interactive walkthrough).