> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enkryptai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect a relay bridge (WebSocket)

> The socket a **relay bridge** opens to Enkrypt so that a model with no inbound network exposure can still be red-teamed. See `target.connect_via_relay` on `POST /rt/redteam` for the request side.

This is a **WebSocket upgrade, not a request/response `GET`** - it is listed here so the address and its headers are documented in one place. There is deliberately no Try-it control on this page, because an HTTP request cannot exercise a WebSocket upgrade. Dial it with `wss://` from a WebSocket client, or just run the `enkryptai-relay` console script that ships in the Python SDK, which does all of this for you. The end-to-end walkthrough is [Red Teaming Through the Relay Bridge](/get-started/redteam/relay-bridge).

The connection is **outbound only and bridge-initiated**: your firewall sees one long-lived HTTPS connection on port 443 and never has to accept an inbound one. Enkrypt pushes OpenAI-shaped `chat.completions` requests down that socket, the bridge calls your own LLM over your intranet, and the response returns the same way.

You do **not** send a user id. Authentication is your `apikey` alone; the gateway resolves the owning account from it and stamps that identity on both this socket and on the runs you submit, which is how a run finds your bridge. Two customers can therefore both name a bridge `customer-bridge-1` without colliding.

If the upgrade is refused, the WebSocket close code says why: `4400` no `x-enkrypt-relay-bridge-id` header, `4401` the API key was not accepted, `4403` the gateway could not resolve an owning account for the key. The socket is otherwise held open indefinitely and the bridge heartbeats over it.

> [!NOTE]
>
> **There is no Try-it control on this page, on purpose.** This address is a WebSocket
> upgrade, not a request/response `GET`, so it cannot be exercised over HTTP — the playground
> is suppressed rather than offered and left to fail. Dial it with `wss://` from a WebSocket
> client, or run the `enkryptai-relay` console script that ships in the Python SDK, which
> does all of this for you.
>
> For the end-to-end walkthrough — running the bridge, confirming it is connected, and
> pointing a run at it — see
> [Red Teaming Through the Relay Bridge](https://docs.enkryptai.com/get-started/redteam/relay-bridge.md).


## OpenAPI

````yaml GET /redteam/relay/v1/relay/bridge
openapi: 3.0.0
info:
  title: Enkrypt AI APIs
  version: 2.0.0
servers:
  - url: https://api.enkryptai.com
security:
  - apiKeyAuth: []
tags:
  - name: Guardrails
  - name: Code of Conduct
  - name: Endpoints
  - name: Redteam
    description: >-
      Red Team API: submit red-team / threat-modeling / playground / eval runs,
      then poll run status, records, results and compliance. Also two-phase
      threat modeling (categories + data), dataset retrieval, model health,
      findings and risk mitigation. The previous task-based Red Team API is
      under **Archived**.
  - name: Deployments
  - name: AI Proxy
  - name: Leaderboard
  - name: Archived
  - name: MCP Hub
    description: >-
      MCP Hub vulnerability scanning APIs. Submitting scans (the POST endpoints)
      is open to all authenticated callers. The scan **retrieval** APIs — Get
      Scan Job Status, Get Complete Scan Results, List Scans, and Get MCP Hub
      Scan Statistics (the GET endpoints) — are an **enterprise data-license
      feature**: they require your organization to have MCP Hub API access
      enabled by Enkrypt, otherwise they return `403`. Contact us at
      support@enkryptai.com to enable access.
  - name: MCP Registry Servers
  - name: MCP Gateways
  - name: MCP Playground
  - name: Skill Scanner
    description: >-
      Skill Scanner APIs: submit an agent skill (a directory inside a git
      repository) for security scanning, then read the verdict, the risk level
      and the full report. Scanning is asynchronous — a scan takes roughly 30–90
      seconds, so `POST /skill-hub/scan` returns a `scan_id` you poll.


      You see your organization's scans and nobody else's. The identity comes
      from your API key, never from your request — sending `user_email` is a
      `400`.


      For an organization or project API key, scans are filed under the
      **organization**, so every member sees every scan the organization has
      run, whichever project or member submitted it. For an individual account
      it is simply your own scans. Either way List Skill Scans needs no
      parameter to say who you are.
  - name: Compliance
    description: >-
      Compliance APIs: connect a ChatGPT Enterprise workspace, then keep reading
      its compliance logs and scanning every message through one of your saved
      guardrails.


      Every endpoint here — reads as well as writes — requires the **governance
      officer** role on the project your API key belongs to. The organization
      owner is **not** exempt: an owner who has not been granted the role gets
      `403` like anyone else. An individual (non-organization) account cannot
      hold the role at all, so compliance is an organization-only feature today.


      A scan is addressed by name in the `X-Enkrypt-Scan` header, within the
      project its API key belongs to. Message text is never stored: Get
      Compliance Message fetches it live from the provider, and only while the
      provider still holds it.
paths:
  /redteam/relay/v1/relay/bridge:
    get:
      tags:
        - Redteam
      summary: Connect a relay bridge (WebSocket)
      description: >-
        The socket a **relay bridge** opens to Enkrypt so that a model with no
        inbound network exposure can still be red-teamed. See
        `target.connect_via_relay` on `POST /rt/redteam` for the request side.


        This is a **WebSocket upgrade, not a request/response `GET`** - it is
        listed here so the address and its headers are documented in one place.
        There is deliberately no Try-it control on this page, because an HTTP
        request cannot exercise a WebSocket upgrade. Dial it with `wss://` from
        a WebSocket client, or just run the `enkryptai-relay` console script
        that ships in the Python SDK, which does all of this for you. The
        end-to-end walkthrough is [Red Teaming Through the Relay
        Bridge](/get-started/redteam/relay-bridge).


        The connection is **outbound only and bridge-initiated**: your firewall
        sees one long-lived HTTPS connection on port 443 and never has to accept
        an inbound one. Enkrypt pushes OpenAI-shaped `chat.completions` requests
        down that socket, the bridge calls your own LLM over your intranet, and
        the response returns the same way.


        You do **not** send a user id. Authentication is your `apikey` alone;
        the gateway resolves the owning account from it and stamps that identity
        on both this socket and on the runs you submit, which is how a run finds
        your bridge. Two customers can therefore both name a bridge
        `customer-bridge-1` without colliding.


        If the upgrade is refused, the WebSocket close code says why: `4400` no
        `x-enkrypt-relay-bridge-id` header, `4401` the API key was not accepted,
        `4403` the gateway could not resolve an owning account for the key. The
        socket is otherwise held open indefinitely and the bridge heartbeats
        over it.
      operationId: rt_relay_bridge_connect_get
      parameters:
        - name: Upgrade
          in: header
          required: true
          schema:
            title: Upgrade
            type: string
            description: Must be `websocket`. Sent for you by any WebSocket client library.
            example: websocket
        - name: x-enkrypt-relay-bridge-id
          in: header
          required: true
          schema:
            title: Bridge ID
            type: string
            description: >-
              The identifier this bridge registers under. Free text you choose,
              and the one value both sides must agree on: it has to equal
              `target.metadata.relay.bridge_id` on the runs you want routed
              here, and it is what `RELAY_BRIDGE_ID` sets on the SDK bridge.
              Scoped to your account, so it only has to be unique within it.
            example: customer-bridge-1
      responses:
        '101':
          description: >-
            Switching Protocols - the bridge is registered and will now receive
            relayed requests on this socket.
        '403':
          description: >-
            The API key did not resolve to an account the bridge can be
            registered under.
components:
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: apikey

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.