---
title: "Connect an MCP client"
description: "Connect Perplexity, ChatGPT, Insomnia, Codex, Claude Code, Cursor, or another compatible client to MCP."
canonical: "https://studio.inttegro.com/inttegro-mcp/connect"
format: inttegro-machine-docs/v1
language: "PHP"
sdk_version: "v12.0.0"
reader_profile: optional
reader_manifest: "https://studio.inttegro.com/machine/php/readers/index.json"
reader_identification: "Optional: declare your client only if known and your current-session capabilities; use reader_manifest for supplemental recommendations."
preamble_estimated_tokens: 423
model_token_report: "https://studio.inttegro.com/machine/token-report.json"
preamble_questions: 5
preamble_source: "curated"
recommended_mcp_tools: ["list_products","design_integration"]
estimated_tokens: 4112
token_estimate_method: "utf8_bytes_divided_by_4"
---

## Machine preamble

**Summary:** Connect a remote Streamable HTTP client to the Inttegro MCP origin, choose an appropriate credential path, then verify organization scope and confirmation support.

### Five questions

#### Q1. What server URL and transport should a client use?

Use the origin-root https://mcp.inttegro.com endpoint with remote Streamable HTTP. Do not append a guessed tool path or substitute an API endpoint for the MCP server.

#### Q2. Which authentication path fits the connection?

Use interactive OAuth for a merchant organization when the client supports it, or a restricted Inttegro API key for a workload connection. Keep the credential out of chat and choose the intended organization during authorization.

#### Q3. Can every connected client perform actions?

No. Confirm that the host can present MCP form elicitation and the exact mutation summary. Without that support, use read-only catalog abilities; [Tool catalog](https://studio.inttegro.com/machine/php/inttegro-mcp/tools.md) defines each tool's boundary.

#### Q4. How should client-specific setup be read?

Use the option for the actual client—ChatGPT, Claude Code, Codex, Cursor, Insomnia, or another listed host. Do not apply one host's token, OAuth, or installation steps to another merely because they share the server URL.

#### Q5. What proves the connection is usable?

Discover the authorized [tool catalog](https://studio.inttegro.com/machine/php/inttegro-mcp/tools.md), make a harmless read such as recent orders or products, and verify that returned records belong to the intended organization. Resync after catalog changes; diagnose auth or confirmation failures before enabling actions.

## Document content

# Connect an MCP client

All clients connect to the same origin-root Streamable HTTP endpoint and discover the same authorized tool catalog.

## Prerequisites

- An Inttegro merchant account and organization for interactive OAuth, or a restricted Inttegro API key for a workload connection
- An MCP client that supports remote Streamable HTTP and bearer authentication
- MCP form elicitation support if the client will perform confirmed actions

## Client configuration

### Insomnia

Open [MCP in Insomnia](https://app.insomnia.rest/run?mcp=https%3A%2F%2Fmcp.inttegro.com), or create an MCP client using:

```text
https://mcp.inttegro.com
```

In **Auth**, select **Bearer Token** and enter the raw Inttegro API key. Insomnia adds the `Bearer` prefix. Click **Connect**, then **Resync** after a server catalog change. A successful connection discovers 80 tools when analytics is configured.

### Perplexity

Perplexity supports Inttegro through an operator-managed custom remote MCP
connector pilot. An Inttegro-provisioned Perplexity OAuth client is required;
never paste its client secret into chat or documentation.

1. Open **Computer → Connectors**.
2. Open **Custom connector**, then select **Add MCP connector**.
3. Enter `Inttegro` as the name.
4. Enter `https://mcp.inttegro.com` as the MCP server URL.
5. Select **OAuth** and enter the dedicated Perplexity client ID and secret.
6. Select **Streamable HTTP** and **Public** network access.
7. Add the connector, complete Inttegro sign-in, and select the organization you
   intend Perplexity to access.

Do not self-provision this connector from the canonical endpoint yet.
Perplexity's generated authorization request currently asks for every scope in
the MCP protected-resource metadata, and its form has no scope selector. The
private pilot succeeds only when an Inttegro operator narrows the authorization
request to the approved read-only profile. If the consent screen includes any
create, update, send, payment, refund mutation, delete, cancel, or lifecycle
permission, cancel instead of broadening the grant.

After connecting, ask Perplexity to show five recent Inttegro orders or list
five products. Confirm that the response belongs to the selected organization.
The confidential pilot client allows `offline_access`, but token refresh and
revocation are not certified yet. Do not enable Perplexity scheduled tasks.

Perplexity write support is not certified. Keep the connector's write/delete
tool group disabled until the exact Perplexity surface proves it can present
Inttegro's MCP form confirmation; host approval alone does not replace that
confirmation.

### ChatGPT

### Desktop app

Use this first when ChatGPT exposes MCP server settings:

1. Open **Settings**, then **MCP servers**.
2. Select **Add server**.
3. Name the server `inttegro`.
4. Choose **Streamable HTTP**.
5. Enter `https://mcp.inttegro.com` as the server URL.
6. Choose **Bearer token** authentication.
7. Enter your Inttegro secret key token.
8. Save the server, restart ChatGPT, then type `/mcp`.

### ChatGPT web

Use Plugins or workspace Apps when your workspace supports custom MCP apps.
Direct Inttegro connector installation is not enabled yet. If ChatGPT asks for
a remote server URL, use:

```text
Name: inttegro
Server URL: https://mcp.inttegro.com
Authentication: Bearer token
Bearer token: <SECRET_KEY_TOKEN>
```

If the ChatGPT surface only supports published connectors or OAuth-only linking
and Inttegro is not available there yet, use Codex, Cursor, or another remote
MCP client.

### Codex

### Desktop app

Use the GUI setup first:

1. Open **Settings**, then **MCP servers**.
2. Select **Add server**.
3. Name the server `inttegro`.
4. Choose **Streamable HTTP**.
5. Enter `https://mcp.inttegro.com` as the server URL.
6. Choose **Bearer token** authentication.
7. Enter your Inttegro secret key token.
8. Save the server, restart Codex, then type `/mcp`.

The ChatGPT desktop app, Codex CLI, and IDE extension share Codex MCP
configuration for the same host, so a server added in one client can be reused
from the others.

### CLI / config.toml

Export the credential in the environment that launches Codex:

```bash
export INTTEGRO_API_KEY=<SECRET_KEY_TOKEN>
```

Add the server to your Codex configuration:

```toml
[mcp_servers.inttegro]
url = "https://mcp.inttegro.com"
bearer_token_env_var = "INTTEGRO_API_KEY"
```

Restart or reload Codex, then ask it to list the available Inttegro tools. See the official [Codex MCP configuration](https://developers.openai.com/codex/mcp/) for configuration-file locations and client controls.

### Claude Code

Add the pre-registered public OAuth client:

```bash
claude mcp add inttegro https://mcp.inttegro.com \
  --transport http \
  --client-id e5FLCFhTxXPvnPbc \
  --callback-port 54113
```

Open `/mcp`, choose **inttegro**, and complete sign-in and organization selection in the browser. Claude stores and refreshes the resulting token; no client secret or merchant API key is required.

Keep `inttegro` and the server URL immediately after `mcp add`. Claude's `--header` option accepts multiple values and can consume trailing positional arguments. Do not add an `Authorization` header to this OAuth connection: Claude disables OAuth fallback whenever that header is configured.

For an intentional static-token connection, use a separate command without the OAuth options:

```bash
export INTTEGRO_API_KEY='replace-with-a-restricted-token'

claude mcp add inttegro https://mcp.inttegro.com \
  --transport http \
  --header "Authorization: Bearer ${INTTEGRO_API_KEY}"
```

For an intentional headless workload instead, export a restricted key and add this entry to `.mcp.json` at your project root:

```json
{
  "mcpServers": {
    "inttegro": {
      "type": "http",
      "url": "https://mcp.inttegro.com",
      "headers": {
        "Authorization": "Bearer ${INTTEGRO_API_KEY}"
      }
    }
  }
}
```

Approve the project configuration when Claude Code asks you to trust it. Run `claude mcp get inttegro` or open `/mcp` to inspect the connection. Keep any workload key in the environment, not in `.mcp.json`.

For the richer Inttegro Claude Code experience, see [Use the Claude Code plugin](https://studio.inttegro.com/machine/php/inttegro-mcp/claude-code.md).

### Cursor

Export the credential, then add this entry to `.cursor/mcp.json` for the project or to your personal MCP configuration:

```json
{
  "mcpServers": {
    "inttegro": {
      "url": "https://mcp.inttegro.com",
      "headers": {
        "Authorization": "Bearer ${env:INTTEGRO_API_KEY}"
      }
    }
  }
}
```

For cloud agents, enter the URL and bearer header through Cursor's MCP settings so the credential remains encrypted and outside the repository.

### Replit

Open **Integrations** in the Replit workspace and add a custom MCP server. Use
`https://mcp.inttegro.com` as the server URL. Complete OAuth if Replit offers it
for the connection; otherwise store a dedicated Inttegro API key in the
connection's protected headers and send it as `Authorization: Bearer YOUR_KEY`.

Verify that Inttegro tools appear before asking Agent to change the application.
Never paste the credential into Agent chat or commit it to the repository. See
[Build with Replit](https://studio.inttegro.com/machine/php/ai-builders/replit.md) for the complete plan-and-build flow.

### Base44

Open your Base44 profile menu, then go to **Settings → MCP connections** and
select **Add custom MCP**. Name it `Inttegro`, use
`https://mcp.inttegro.com` as the URL, choose OAuth, and complete Inttegro
sign-in. Select **Test & add**, then confirm that the connection is enabled.

Base44 exposes the connection only to its AI chat while you build. Keep live
Inttegro requests in a backend function with `INTTEGRO_API_KEY` stored under
**Dashboard → Secrets**. See [Build with Base44](https://studio.inttegro.com/machine/php/ai-builders/base44.md) for the
complete plan, function boundary, and testing flow.

### Bolt

Open **MCP connectors** in Bolt and create a custom HTTP connection for
`https://mcp.inttegro.com`. Complete MCP OAuth when the connection offers it; if
it does not, add a dedicated Inttegro API key through the connector's protected
authentication settings.

Enable only the tools the project needs, then verify the connection before
building. Keep live Inttegro API calls in server functions or a trusted backend.
See [Build with Bolt](https://studio.inttegro.com/machine/php/ai-builders/bolt.md) for the complete boundary.

### Lovable

Use a custom authenticated MCP connector when the Lovable workspace supports
one. The connection helps Lovable plan and build; it is not part of the
published application. Live Inttegro requests must run from a Lovable Cloud Edge
Function or another trusted backend with the key in its secret store.

See [Build with Lovable](https://studio.inttegro.com/machine/php/ai-builders/lovable.md) for the exact build-time and
runtime split.

### v0

From a v0 chat, open **Connect**, select **Add MCP**, and configure a custom MCP
server at `https://mcp.inttegro.com`. Choose OAuth and complete Inttegro sign-in.
Keep MCP tool approval on **Ask** while the project can perform write operations.

The connection gives v0 Inttegro tools while it generates the application; it
does not give the published app runtime access to MCP. Keep live API calls in
Next.js server code and store `INTTEGRO_API_KEY` in the Vercel project's
environment variables. See [Build with v0](https://studio.inttegro.com/machine/php/ai-builders/v0.md) for the complete
generation-to-deployment workflow.

### Google AI Studio

Google documents external MCP tools in the **Agents playground**, separately
from its app-building surface. Connect `https://mcp.inttegro.com` to an agent
with the least privilege available, use it to create an Inttegro integration
plan, and review that plan before taking the approved brief into **Build mode**.

The generated application does not inherit the agent's MCP connection. Store
`INTTEGRO_API_KEY` in Build mode's **Settings → Secrets** and keep live calls in
the server runtime. See [Build with Google AI Studio](https://studio.inttegro.com/machine/php/ai-builders/google-ai-studio.md)
for the complete handoff and publishing flow.

### Other clients

Use these settings in any client that supports remote Streamable HTTP and custom headers:

```text
Name: inttegro
URL: https://mcp.inttegro.com
Authorization: Bearer <SECRET_KEY_TOKEN>
```

Environment-variable syntax is not standardized. Use the client's documented secret facility and verify that it sends the header only to the exact origin above.

## OpenAI and Anthropic API connectors

Applications using the OpenAI Responses API can provide the server URL as `server_url` and the restricted Inttegro key as `authorization`. Limit `allowed_tools` to the request and keep approval enabled for consequential calls. See OpenAI's [remote MCP guide](https://developers.openai.com/api/docs/guides/tools-connectors-mcp).

Applications using Anthropic's MCP connector can provide the same URL and key from their server-side secret store. The application—not the model or browser—owns acquiring, storing, and rotating that credential.

## Verify the connection

1. Connect or resync the server.
2. Confirm the client discovers 80 tools when analytics is configured.
3. Call a narrow read such as `list_products` with a small limit.
4. Confirm the result belongs to the expected Inttegro application.
5. Before enabling actions, verify the client can display MCP form elicitation and require visible merchant confirmation.

If a client cannot carry form elicitation safely, keep the connection read-only. Do not replace server confirmation with model-generated approval text.

## Turn the connection into an integration plan

After verifying the connection, let the MCP prepare the integration brief instead of collecting SDK, checkout, endpoint, and testing instructions manually:

> Use `design_integration` to help me choose our server runtime, SDK approach, first workflow, and checkout experience. Then give my coding agent the exact initial operations, implementation steps, Studio links, and end-to-end tests.

The tool is read-only and does not accept an API key. See [Design an integration](https://studio.inttegro.com/machine/php/inttegro-mcp/design-integration.md) for every choice, result field, and agent-handoff step.

## Troubleshoot

| Symptom                                      | Check                                                                                                                         |
| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| OAuth sign-in does not open                  | The client uses ID `e5FLCFhTxXPvnPbc`, callback port `54113`, and the exact server origin above                               |
| Claude treats `inttegro` as a header value   | Put `inttegro https://mcp.inttegro.com` immediately after `claude mcp add`; `--header` is variadic                            |
| A static token fails and OAuth does not open | Remove the configured `Authorization` header before using the OAuth client; the two authentication modes must not be combined |
| No tools appear                              | The client supports remote Streamable HTTP; reconnect or resync after configuration changes                                   |
| Reads work but actions fail                  | The client supports MCP form elicitation                                                                                      |

Next, review the [tool catalog](https://studio.inttegro.com/machine/php/inttegro-mcp/tools.md) or try the [merchant workflows](https://studio.inttegro.com/machine/php/inttegro-mcp/workflows.md).
