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

# Get Federation Configuration for a Connection

> Returns the IAM federation configuration for a connection. The admin credentials are never returned in plaintext; only a presence indicator is included.



## OpenAPI

````yaml https://use.hoop.dev/api/openapiv3.json get /connections/{nameOrID}/federation
openapi: 3.0.3
info:
  contact:
    email: help@hoop.dev
    name: Help
    url: https://help.hoop.dev
  description: >-
    Hoop.dev is an access gateway for databases and servers with an API for
    packet manipulation
  license:
    name: MIT
    url: https://opensource.org/license/mit
  termsOfService: https://hoop.dev/docs/legal/tos
  title: Hoop Api
  version: 1.115.0
servers:
  - url: https://use.hoop.dev/api
security: []
tags:
  - description: >
      Hoop implements Oauth2 and OIDC protocol to authenticate users in the
      system. To obtain a valid access token users need to authenticate in their
      own identity provider which is generated as a JSON response to the
      endpoint `http(s)://use.hoop.dev/api/login`. The identity provider them
      redirects the user to the callback endpoint containing the access token.


      The recommended approach of obtaining an access token is by visiting the
      Webapp main's page or using the **Hoop command line**. Example:


      ```sh

      hoop config create --api-url https://use.hoop.dev

      # save the token after authenticating at $HOME/.hoop/config.toml

      hoop login

      # show token information

      hoop config view --raw

      ```


      With an access token you could use any HTTP client to interact with the
      documented endpoints.

      The token must be sent through the `Authorization` header.


      Example:


      ```sh

      # obtain the current configuration of the server

      curl https://use.hoop.dev/api/serverinfo -H "Authorization: Bearer
      $ACCESS_TOKEN"

      ```
    name: Authentication
  - description: >
      Users are active and assigned to the default organization when they
      signup. A user could be set to an inactive state preventing it from
      accessing the platform, however it’s recommended to manage the state of
      users in the identity provider.


      - The `sub` claim is used as the main identifier of the user in the
      platform.

      - The profile of the user is derived from the id_token claims `email` and
      `name`.


      When a user authenticates for the first time, it performs an automatic
      signup that persist the profile claims along with it’s unique identifier.

      ​

      ### Groups


      Groups allows defining who may access or interact with certain resources.


      - For connection resources it’s possible to define which groups has access
      to a specific connection, this is enforced when the Access Control feature
      is enabled.

      - For review resources, it’s possible to define which groups are allowed
      to approve an execution, this is enforced when the Review feature is
      enabled.


      > This resource could be managed manually via Webapp or propagated by the
      identity provider via ID Token. In this mode, groups are sync when a user
      performs a login.


      ### Roles


      - The `admin` group is a special role that grants full access to all
      resources


      This role should be granted to users that are responsible for managing the
      Gateway. All other users are regular, meaning that they can access their
      own resources and interact with connections.
    name: User Management
  - name: Machine Identities
  - description: Routes used to manage and obtain information about the runtime server.
    name: Server Management
  - description: Features available in the gateway. See also **Plugin** resources.
    name: Features
  - description: >-
      Proxy manager endpoints controls how clients connect via gRPC in the
      gateway. These endpoints are meant to be used when a client is initialized
      via `hoop proxy-manager`.
    name: Proxy Manager
  - name: Connections
  - name: Agents
  - name: Runbooks
  - name: Guard Rails
  - name: Reviews
  - name: Sessions
  - name: Organization Management
  - name: Reports
  - description: >
      Security audit log API. Only users in the **admin** group can access these
      endpoints.


      Audit log entries record security-relevant events (who performed an
      action, when, on which resource, and whether it succeeded). Use the list
      endpoint with filters to query by actor, resource type, action, outcome,
      or date range. Results are paginated and ordered by `created_at`
      descending.
    name: Audit Logs
paths:
  /connections/{nameOrID}/federation:
    get:
      tags:
        - Connections
      summary: Get Federation Configuration for a Connection
      description: >-
        Returns the IAM federation configuration for a connection. The admin
        credentials are never returned in plaintext; only a presence indicator
        is included.
      parameters:
        - description: Name or UUID of the connection
          in: path
          name: nameOrID
          required: true
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/openapi.ConnectionFederationConfig'
          description: OK
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/openapi.HTTPError'
          description: Not Found
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/openapi.HTTPError'
          description: Internal Server Error
components:
  schemas:
    openapi.ConnectionFederationConfig:
      properties:
        admin_credentials_json:
          description: >-
            AdminCredentialsJSON is the plaintext admin credential blob. Its
            shape is

            provider-specific: for gcp_iam it is the admin service-account JSON;
            for

            gcp_oauth it is the OAuth client config JSON ({"client_id":"...",

            "client_secret":"..."}). Write-only — never returned on GET.
            Required on

            the initial POST when HookSource=builtin; optional on PUT (omitting
            it

            leaves the stored value unchanged).
          type: string
        builtin_provider:
          description: >-
            BuiltinProvider is required when HookSource=builtin. "gcp_iam"

            impersonates a per-user service account via an admin SA key;
            "gcp_oauth"

            mints tokens from a per-user Google OAuth refresh token (no service

            accounts).
          enum:
            - gcp_iam
            - gcp_oauth
          example: gcp_iam
          type: string
        connection_id:
          description: |-
            ConnectionID is the connection this federation config applies to.
            Populated by the server from the URL path on writes.
          example: 15B5A2FD-0706-4A47-B1CF-B93CCFC5B3D7
          type: string
        created_at:
          description: CreatedAt / UpdatedAt are server-set audit timestamps.
          example: '2025-05-25T17:00:00Z'
          type: string
        extra_config:
          additionalProperties: {}
          description: |-
            ExtraConfig is provider-specific freeform JSON (e.g. {"project_id":
            "my-gcp-proj"}). The gateway does not interpret unknown keys.
          type: object
        fallback_policy:
          description: >-
            FallbackPolicy controls behavior when resolution fails. "deny"
            aborts

            the session; "static" skips federation and lets the session run on
            the

            connection's existing static credentials.
          enum:
            - deny
            - static
          example: deny
          type: string
        has_admin_credentials:
          description: >-
            HasAdminCredentials is server-set on GET responses to let the UI
            know

            whether a credential is stored without exposing its value.
          example: true
          type: boolean
        hook_source:
          description: >-
            HookSource selects which resolver category the gateway runs. Only
            the

            built-in resolver category ships today; the field is preserved so
            new

            sources can be added without breaking existing configurations.
          enum:
            - builtin
          example: builtin
          type: string
        id:
          description: >-
            ID is the federation row's UUID. Empty on POST requests; populated
            on

            GET/PUT responses.
          example: 15B5A2FD-0706-4A47-B1CF-B93CCFC5B3D7
          type: string
        identity_source_attribute:
          description: >-
            IdentitySourceAttribute is a JSONPath-like accessor into the Hoop
            user

            (defaults to $.user.email).
          example: $.user.email
          type: string
        identity_target_template:
          description: >-
            IdentityTargetTemplate is the principal template the source
            attribute

            substitutes into (defaults to "{user.email}").
          example: '{user.email}'
          type: string
        token_ttl_seconds:
          description: |-
            TokenTTLSeconds caps the lifetime of generated credentials (default
            3600, max 43200). Built-in providers may clamp lower based on cloud
            API limits.
          example: 3600
          type: integer
        updated_at:
          example: '2025-05-25T17:00:00Z'
          type: string
      required:
        - hook_source
      type: object
    openapi.HTTPError:
      properties:
        message:
          example: the error description
          type: string
      type: object

````