Zenifra MCP

Zenifra MCP connects compatible AI clients to your Zenifra account for authorized queries about projects, metrics, builds, usage, and payments. The connection uses browser-based OAuth and remains read-only.

What Zenifra MCP is

The Model Context Protocol (MCP) lets an AI client query information from a connected service. Zenifra's public endpoint is:

https://mcp.zenifra.com/mcp

Zenifra MCP does not create, change, or delete projects. It exposes only the data that the connected account is authorized to view. Authorization selects one organization per connection and lets you review access before confirming.

What you can access

After OAuth, the client can query the following, depending on the access you approve:

connected account and organization context;
authorized project list;
details for one authorized project;
current project metrics when available;
authorized project builds, deployments, and logs;
application health, instances, network analytics, and auto-scaling;
Valkey project status;
metadata for authorized AI models and keys, without credentials;
AI usage for a rolling period;
project measurement and billing information;
organization transactions when financial access is authorized separately.

The MCP server publishes concise tool names:

Tool	Purpose
`get_context`	Read the connected account and organization context.
`list_projects`	List authorized projects.
`get_project`	Read one authorized project.
`get_project_metrics`	Read current project metrics.
`list_builds`	List project build metadata.
`get_project_logs`	Read recent, bounded application logs.
`get_build_logs`	Read paginated logs for one build.
`list_deployments`	List deployments recorded in the current month.
`get_project_health`	Read health check availability and configuration.
`list_healthcheck_failures`	List recent health check failures.
`get_project_network`	Read network summaries, routes, responses, and events.
`get_project_autoscaling`	Read the current auto-scaling configuration.
`list_autoscaling_events`	List recent capacity increase or reduction events.
`list_project_instances`	List public instance identifiers.
`get_valkey_status`	Read public status and configuration for a Valkey project.
`list_ai_keys`	List authorized AI key metadata without credentials.
`get_ai_usage`	Read observed AI usage.
`get_project_billing`	Read project measurements or ledger entries.
`list_transactions`	List authorized organization transactions.

Clients may display a server namespace before these names. With a server named zenifra, for example, get_context may appear as zenifra_get_context. Do not add zenifra_ to the MCP tool name itself.

Financial data requires separate consent during authorization. Lack of financial access does not prevent permitted project and metric queries.

Before connecting

Have an active Zenifra account, access to the organization you want to query, and a client that supports remote HTTPS MCP servers with OAuth. Always use the complete endpoint ending in /mcp.

You do not need to create a manual token or provide a static credential to the client. Sign-in happens in the browser when the client starts the OAuth flow.

Where to add the configuration

Prefer the client's own command when one is available. The command writes the expected format and reduces the risk of editing the wrong file. For manual configuration, these are the most common paths on Linux and macOS:

Client	User configuration	Project configuration
Codex	`~/.codex/config.toml`	`<project>/.codex/config.toml`
Claude Code	`~/.claude.json`	`<project>/.mcp.json`
OpenCode	`~/.config/opencode/opencode.json` or `.jsonc`	`<project>/opencode.json` or `<project>/.opencode/opencode.json`
Pi	`~/.pi/agent/mcp.json` or `~/.config/mcp/mcp.json`	`<project>/.mcp.json` or `<project>/.pi/mcp.json`
Hermes Agent	`~/.hermes/config.yaml`	—

~ represents the user's home directory. User configuration is available across projects; project configuration applies only to that directory and can be shared with the team when the client supports it.

In Codex and Claude Code, prefer codex mcp add and claude mcp add to write the configuration. In OpenCode and Pi, edit JSON/JSONC or use the client's own management interface. In Hermes Agent, edit YAML and run hermes mcp login zenifra.

Add only the public URL and the fields shown in this guide. Do not place access tokens, refresh tokens, client secrets, or cookies in these files. Each client stores OAuth credentials through its own authentication flow. On Windows, prefer the client commands and consult its official reference to locate the corresponding file.

Connect from Codex

Add the server and start login from the terminal:

codex mcp add zenifra --url https://mcp.zenifra.com/mcp
codex mcp login zenifra
codex mcp list

The browser opens for sign-in and consent review. After authorizing, use codex mcp list to confirm that the server is connected. The Codex app also lets you add the server and start OAuth from MCP settings.

See the official Codex MCP reference for options specific to your installed version.

Connect from Claude Code

Add the server at user scope:

claude mcp add --transport http --scope user zenifra https://mcp.zenifra.com/mcp
claude mcp list

Claude Code starts OAuth when you first use the server or request server authentication. Sign in in the browser, review the organization and access, and confirm. Then use claude mcp list to check the status.

See the official Claude Code MCP reference for the management commands available in your version.

Connect from OpenCode

Zenifra supports automatic public-client registration for both formats. Do not add clientId, clientSecret, client_id, or client_secret to the configuration.

OpenCode 1.x

For OpenCode 1.x, including the 1.18 series, add the remote server directly inside mcp:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "zenifra": {
      "type": "remote",
      "url": "https://mcp.zenifra.com/mcp",
      "enabled": true
    }
  }
}

Start authentication and confirm the status from the terminal:

opencode mcp auth zenifra
opencode mcp list

The browser flow selects the Zenifra organization, resources, and access for the connection. The OpenCode 1.x server is ready only after opencode mcp list reports that it is connected.

OpenCode V2

For OpenCode V2, use mcp.servers.zenifra:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "servers": {
      "zenifra": {
        "type": "remote",
        "url": "https://mcp.zenifra.com/mcp"
      }
    }
  }
}

The official OpenCode V2 reference uses the MCP management interface to authenticate remote servers. Open that interface, start authentication for the Zenifra server, and complete OAuth in the browser. The flow selects the Zenifra organization, resources, and access for the connection. The OpenCode V2 server is ready only after the V2 MCP interface reports that it is connected.

See the official OpenCode MCP server reference and the official OpenCode V2 reference for configuration and authentication details.

Connect from Pi

Install the package that adds MCP server support to Pi:

pi install npm:pi-codemcp

Add the Zenifra server to Pi's MCP configuration:

{
  "mcpServers": {
    "zenifra": {
      "type": "http",
      "url": "https://mcp.zenifra.com/mcp",
      "auth": "oauth"
    }
  }
}

In Pi, use /codemcp to start OAuth and inspect the connection status. Authorize the desired organization in the browser before making the first query.

See the official pi-codemcp reference for the configuration path and available commands.

Connect from Hermes Agent

Add the HTTP OAuth server to the Hermes Agent configuration file:

mcp_servers:
  zenifra:
    url: "https://mcp.zenifra.com/mcp"
    auth: oauth

Start authentication and reload MCP tools when needed:

hermes mcp login zenifra

Complete OAuth in the browser and confirm that Zenifra tools appear after reloading. For remote or headless connections, follow the official Hermes Agent remote OAuth guide.

Verify the connection

The verification flow is the same in every client:

Add the HTTPS endpoint ending in /mcp.
Start OAuth from the action documented by the client.
Sign in to Zenifra in the browser.
Select one organization and review the requested access.
Authorize the connection.
Return to the client and confirm that Zenifra tools are available.
Make a first query for the connected context or authorized project list.

Before OAuth is complete, an unauthenticated request returns 401. This is the expected challenge that starts authorization. Consider the connection verified only after OAuth completes and a read-only query returns data that your account can view.

Permissions and reconnection

Each OAuth connection is associated with the organization selected during consent. To query another organization, reconnect the account and select the new organization when the client starts the flow again.

The consent screen also shows the requested resources and access. Financial access is separate and must be explicitly approved. If you change the organization or access you want, use the client's reconnect action and review consent again.

Troubleshooting

No OAuth prompt: confirm that the URL ends in /mcp and start the client's login action.
401 after login: reconnect the Zenifra account and complete consent again.
403 or missing data: reconnect and review the organization, resources, and access selected during consent.
No tools available: confirm that the server is enabled, authenticated, and reloaded in the client.
Remote or headless connection failure: follow the selected client's official remote authentication guide.

Example prompts

After verifying the connection, try queries such as:

Which organization is connected?

List the projects I can query.

Show the current metrics for the authorized project I name.

List recent builds for the selected project and show the logs for the build I specify.

Check this project's health, instances, and auto-scaling events.

Show a network summary for the last hour and recent health check failures.

Show my available AI usage period and authorized transactions.

The client should answer only with data covered by the connection's consent.

Next steps and official references

Use the Zenifra CLI for terminal operations, including supported create and change actions.
Zenifra authentication to learn about the platform's login methods.
Codex MCP
Claude Code MCP
Stable/1.x OpenCode MCP servers
OpenCode V2 MCP servers
pi-codemcp
Hermes Agent MCP

On this page