Toolport for Teams

One setup for the whole team.

Share one MCP server set across your team's Toolport apps. Add a server once and it shows up for every teammate, in every agent they use. Keys are never shared: each person signs in with their own account or adds their own key.

$19 a month for the whole team, up to 10 people, then $4 each.

Create your team See pricing

14-day Team trial. No card. One trial per account. If it ends without a plan, the team keeps its setup and new people cannot join until you subscribe. Just you on a few machines? That is Pro, $5 a month.

Acme Engineering · 5 people

AYou admin Stripe, for everyone

Toolport Teams shares setup, never keys

MMaya Cursor Own key added
SSam Claude Code Own key added
PPriya Codex Own key added
LLeo OpenCode Own key added

Everyone has Stripe. Each person used their own key; Teams never saw one.

pro$5a month, just you, every machine

team$19a month, up to 10 people

self-host$0up to 10, with Docker

Compare plans →

What teammates see

The team's servers, with their own keys.

Team servers arrive in each person's Toolport on the next sync. Each person signs in on their own machine or adds their own key, and Toolport shows what is still missing.

Toolport Teams member view for Acme Engineering: GitHub, Linear, Sentry, Notion, Cloudflare and Playwright ready, Stripe asking for the member's own key — A teammate's view. Stripe needs Sam's own key; everything else is ready. Sample team.

What Team adds

Control without a cloud proxy.

Calls still go straight from each machine to each server. Teams decides what each person's Toolport is allowed to use.

Share servers, never keys

Teams syncs server settings and strips recognized secrets. Each person's keys and sign-ins stay in their own OS keychain.
- StripeShared
- STRIPE_SECRET_KEYOn each computer
Choose who gets what

Give a server to everyone or to some people, and allow or deny single tools.
- StripeBilling group
- github: delete_repoDenied
See every change

Every change shows who made it and what it did. Roll back to an earlier version when you need to.
- v14 · Maya added SentryReview
- v13 · PublishedLive

How a team gets set up

Create a team, add servers, invite people.

The team lead creates the team, adds servers, sets access and invites people in the dashboard. Open the invitation link, sign in and join in your browser. Then choose Connect Toolport and approve the device or use its one-time connection code.

01
Create the team
Sign in with GitHub, Google or email. The 14-day trial starts on its own for your first team, once per account, with no card.
02
Add your servers
Pick from the catalog or add your own. Share credential references; do not paste secrets into shared commands, URLs or instructions.
03
Set who gets what
Give everyone a server, or limit it to some people. Allow or deny single tools.
04
Invite people
Open the invitation link, sign in and join in your browser. Then choose Connect Toolport and approve the device or use its one-time connection code. Each person signs in to upstream servers on their own machine. Config downloads are also available.

Change review

Browser review by default.

On multi-person account-owned teams, an admin's desktop changes wait for browser review by default. Owners can enable direct publishing. Members cannot publish configuration changes.

Who, how and what: Every change shows who made it, whether it came from the browser or a desktop app, and a before and after for each setting.
Who has which version: A grid shows the version each person's app last reported. Review and confirm a rollback to a retained version; Free and Pro show five versions, Team shows fifty.
Fresh codes for sensitive actions: When 2FA is enabled, publishing and selected sensitive browser actions ask for a fresh code after 15 minutes. Owners can require admin enrollment.
Devices that come and go: Desktop sign-ins expire after 90 days unused. A new device shows its name and IP when you approve it. Device approval emails are sent when email delivery is configured.

Changes, example

v14  waiting    sam, from the desktop app on sam-laptop
     github   deny tool   + delete_repo
     linear   url         .../sse  ->  .../mcp
# nobody gets v14 until an admin publishes it
v13  current    published in the browser
     accepted   7 of 9 people

Use without the app

Not everyone has to install anything.

Download the team's servers as a config file your client already reads, from the Servers page in the browser.

Four clients: Claude Code, Cursor, VS Code and Codex. For Claude Code, a project .mcp.json or a machine-wide managed file.
Only what they can use: Each person's download has only the servers they have access to.
Names, not keys: The file names variables, never values. An env: reference becomes the client's own variable, set on each person's machine.
Key references: Each server's key can point at 1Password (op://), Doppler, Infisical, Vault or an environment variable. Teams is designed to store credential references, not upstream credential values. The Toolport app reads the key from there on each person's machine.

.mcp.json, downloaded for Claude Code

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    },
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/mcp",
      "headers": { "Authorization": "${LINEAR_AUTH}" }
    }
  }
}

The honest limit: a download is a snapshot. Download again after the team changes. It does not bring Toolport's safety checks, rate limits or access changes with it; the app does.

The dashboard

Who has what, in one place.

Shared servers, members, roles and reported activity sit in one dashboard instead of in config files. Home lists what needs you: a missing key, a server waiting for someone's review, an invite nobody accepted.

Toolport Teams admin Home: 2 of 5 people ready; Sam Lee needs a key for Stripe, Priya Patel has Playwright waiting for review, Leo Brooks's Toolport is out of date, one invite not accepted — The admin's Home. Teams knows a key is missing, never what the key is. Sample team.

The fine print, up front

What Teams does not do.

It is not a proxy.: Calls go straight from each machine to each server, and team policy covers calls that go through Toolport. A teammate who routes around it is outside policy.
Keys are never uploaded.: Teams strips recognized secret fields and rejects known secret patterns. Do not paste keys into shared commands, URLs or instructions.
Local commands need consent.: A server that runs a command on a teammate's computer, or reaches their private network, waits until they approve it in Toolport.
Downloads are snapshots.: Config downloads for Claude Code, Cursor, VS Code and Codex work without the app, but downloads are snapshots and do not enforce team policy.

How it compares

Ways to share MCP config, side by side.

Handing a teammate a config file is not the same as sharing a setup. Here is what each approach actually does.

Approach	What it shares	Where it works	Controls	Keys
mcp.json in the repo	A config file each teammate has to read and trust.	The clients that read that file, per repository.	None at runtime; a teammate can edit it.	Kept out of the file with variable expansion, but easy to leak into git.
Cursor Team MCP	Shared MCP servers distributed to Cursor from its admin dashboard.	Cursor clients.	Cursor's own admin controls.	Managed through Cursor.
Docker MCP profiles	Profiles and catalogs published to a registry.	Docker MCP clients.	Profile selection; credentials stay out of shared profiles.	Read at call time from where they already live.
Toolport Teams	The approved server set, synced alongside everyone's own servers, or downloaded as a native config.	45 agents including Claude Code, Cursor and Codex, on every machine. Claude Code, Cursor, VS Code and Codex also work without the app.	Per-server and per-tool access, roles and a tighten-only team policy. On multi-person account-owned teams, an admin's desktop changes wait for browser review by default. Owners can enable direct publishing. Members cannot publish configuration changes.	Sign-in stays on each device. Teams syncs credential references and strips recognized secret fields; do not paste secrets into shared text.

Straight answers

Questions about shared setup.

Do my team's API keys get uploaded to Toolport's servers?

Toolport stores upstream credentials in each person's OS keychain and sends them to their configured upstream server when needed. Teams is designed to sync configuration and credential references, not upstream credential values. It strips recognized secret fields and rejects known secret patterns; do not paste secrets into shared commands, URLs or instructions. Sharing one of your own servers keeps your personal original yours. A server can name a 1Password, Doppler, Infisical or Vault reference. The Toolport app reads the key from there on each person's machine.

Can a teammate change the shared setup from their desktop?

On multi-person account-owned teams, an admin's desktop changes wait for browser review by default. Owners can enable direct publishing. Members cannot publish configuration changes. Each change shows who made it, how it arrived and a before and after. Review and confirm a rollback to a retained version; Free and Pro show five versions, Team shows fifty.

Can someone use the team's servers without installing Toolport?

Yes. Download the servers you have access to as a Claude Code, Cursor, VS Code or Codex config. Keys stay out of the file; each person sets them as variables on their own machine. A download is a snapshot, and it does not bring Toolport's safety checks, rate limits or access changes with it. The app does.

Why not just commit an mcp.json to the repo?

That shares a file, not a setup. Each person still pastes keys, each agent wants its own format, and nobody can see who has what. Team keeps one list, per-person sign-in and an audit log, and applies policy to calls that go through Toolport.

Can we share local commands or private-network servers?

Yes. Each person reviews a local command or private-network server before it runs, and needs the local dependencies, network access and credentials it uses.

Which AI agents does it work with?

The 45 agents Toolport detects, including Claude Code, Claude Desktop, Cursor, VS Code and Codex, plus Open WebUI over HTTP. Claude Code, Cursor, VS Code and Codex can also use a downloaded config without the app. See every supported agent

How does it compare to Cloudflare MCP portals?

Cloudflare centres on remote HTTP MCP at the edge. Toolport is local-first: the shared server set and policy sync from Teams, keys stay on each person's machine, and each local gateway applies the policy to calls routed through it. Read the comparison

What does it cost?

Team is $19 a month for up to 10 people, then $4 each, with 14 days free and no card. Just you on several machines is Pro, $5 a month. Self-host is free up to 10 people; over that, email team@toolport.app for a license. Every plan and the billing FAQ

Self-host

Run Teams on your own server.

Free for up to 10 people; beyond that, email team@toolport.app for a license. Teams state stays on infrastructure you run, members still sign in on their own machines, and the MCP and model services you configure still receive the requests you send them. You need a server, a domain with ports 80 and 443 open, and a GitHub OAuth app.

Show the Docker Compose setup

Create a sign-in app (2 min). The dashboard signs your team in with GitHub. At github.com/settings/developers → New OAuth App, set Homepage URL to https://teams.yourco.com (your domain) and Authorization callback URL to https://teams.yourco.com/auth/github/callback. Copy the Client ID and generate a Client secret.

Pull and run. Save the compose below on your box, set these as a .env beside it, then docker compose up -d (Caddy fetches HTTPS automatically): TEAMS_DOMAIN and TOOLPORT_TEAMS_BASE_URL (your https domain), TOOLPORT_TEAMS_BOOTSTRAP (openssl rand -hex 16), GITHUB_CLIENT_ID / GITHUB_CLIENT_SECRET from step 1, and leave TOOLPORT_TEAMS_LICENSE unset for the free 10-seat tier.

docker-compose.yml

# docker-compose.yml
services:
  toolport-teams:
    image: ghcr.io/btsouth/conduit-teams:latest
    restart: unless-stopped
    environment:
      TOOLPORT_TEAMS_BIND: 0.0.0.0:8787
      TOOLPORT_TEAMS_DB: /data/conduit-teams.db
      TOOLPORT_TEAMS_BASE_URL: ${TOOLPORT_TEAMS_BASE_URL}   # https://teams.yourco.com
      TOOLPORT_TEAMS_BOOTSTRAP: ${TOOLPORT_TEAMS_BOOTSTRAP}  # openssl rand -hex 16
      GITHUB_CLIENT_ID: ${GITHUB_CLIENT_ID}
      GITHUB_CLIENT_SECRET: ${GITHUB_CLIENT_SECRET}
      TOOLPORT_TEAMS_LICENSE: ${TOOLPORT_TEAMS_LICENSE}      # omit for the free 10-seat tier
    volumes: ["teams-data:/data"]
    expose: ["8787"]
  caddy:
    image: caddy:2
    restart: unless-stopped
    depends_on: [toolport-teams]
    ports: ["80:80", "443:443"]
    command: caddy reverse-proxy --from ${TEAMS_DOMAIN} --to toolport-teams:8787
    volumes: ["caddy-data:/data", "caddy-config:/config"]
volumes:
  teams-data:
  caddy-data:
  caddy-config:

Open your domain and set up. Visit https://teams.yourco.com, click Sign in with GitHub, then Create team → Add server → Invite, all in the browser.
Your team joins. Open the invitation link, sign in and join in your browser. Then choose Connect Toolport and approve the device or use its one-time connection code. Install the free Toolport app to sync the shared servers.

The image and default database path still use the conduit-teams name for backward compatibility; it is the current Toolport for Teams server. Cert will not issue? It is almost always DNS that has not propagated or port 80 blocked. Bought a Team license? Set it as TOOLPORT_TEAMS_LICENSE and restart.