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

# Join a room with an invite link

> Redeem an invite link and get credentials to join the room. No account needed.

Connect a client to `url` with `token`. The token is short-lived and the guest is
disconnected when it expires; the translator joins the room by itself once two
languages are present.

**This spends one of the link's uses**, so it is not repeatable — a guest who reloads
and joins again consumes another.

Send `languages` from `active_languages`, as many as the preview's
`languages_required` — one for a `dual` room, two for a `mono` one. Both refusals are
409 and **neither spends a use**, so a chooser rendered against a stale preview costs
the guest nothing but a retry: a language that would make a third in the room, and a
count that disagrees with the room's mode. If the room has no mode yet, this count
settles it — one language makes it `dual`, two makes it `mono` — for its lifetime.

The guest's `identity` is assigned here rather than requested. They are
unauthenticated, so accepting one would let them join as any name they liked — and be
attributed as that name in the host's usage breakdown.

404 and 410 mean what they do on `GET /v1/invites/{invite_code}`.



## OpenAPI

````yaml https://api.staging.glot.com/openapi.json post /v1/invites/{invite_code}/join
openapi: 3.1.0
info:
  title: glot-api
  version: 0.1.0
servers:
  - url: https://api.staging.glot.com
security: []
tags:
  - name: rooms
    description: Create translation rooms and let participants join them.
  - name: invites
    description: Invite links that let a guest join a room without an account.
  - name: usage
    description: Minutes and charges over time, for reporting and charts.
  - name: billing
    description: Buy prepaid credit and review the balance behind it.
  - name: api-keys
    description: Create and revoke keys used to authenticate requests.
  - name: supported-languages
    description: Languages available for translation.
  - name: users
    description: The authenticated user's own profile.
paths:
  /v1/invites/{invite_code}/join:
    post:
      tags:
        - invites
      summary: Join a room with an invite link
      description: >-
        Redeem an invite link and get credentials to join the room. No account
        needed.


        Connect a client to `url` with `token`. The token is short-lived and the
        guest is

        disconnected when it expires; the translator joins the room by itself
        once two

        languages are present.


        **This spends one of the link's uses**, so it is not repeatable — a
        guest who reloads

        and joins again consumes another.


        Send `languages` from `active_languages`, as many as the preview's

        `languages_required` — one for a `dual` room, two for a `mono` one. Both
        refusals are

        409 and **neither spends a use**, so a chooser rendered against a stale
        preview costs

        the guest nothing but a retry: a language that would make a third in the
        room, and a

        count that disagrees with the room's mode. If the room has no mode yet,
        this count

        settles it — one language makes it `dual`, two makes it `mono` — for its
        lifetime.


        The guest's `identity` is assigned here rather than requested. They are

        unauthenticated, so accepting one would let them join as any name they
        liked — and be

        attributed as that name in the host's usage breakdown.


        404 and 410 mean what they do on `GET /v1/invites/{invite_code}`.
      operationId: join_with_invite_v1_invites__invite_code__join_post
      parameters:
        - name: invite_code
          in: path
          required: true
          schema:
            type: string
            title: Invite Code
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/GuestJoinRequest'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GuestJoinTokenResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
components:
  schemas:
    GuestJoinRequest:
      properties:
        languages:
          items:
            $ref: '#/components/schemas/LanguageCode'
          type: array
          maxItems: 2
          minItems: 1
          title: Languages
          description: >-
            The languages this guest speaks and wants to hear, each one of the
            `active_languages` from `GET /v1/invites/{invite_code}`.


            **Send exactly as many as that response's `languages_required`.**
            One for a `dual` room — the guest is on their own device — and two
            for a `mono` room, where one device carries both speakers. A count
            that disagrees with the room's mode returns 409 and spends none of
            the link's uses.


            When `languages_required` is `null` the room has no mode yet and
            this count settles it, exactly as the first room token would: one
            language makes the room `dual`, two makes it `mono`, and it is fixed
            from then on.
          examples:
            - - en-GB
            - - en-GB
              - zh-CN
      type: object
      required:
        - languages
      title: GuestJoinRequest
      description: >-
        The languages a guest is joining in.


        The same shape as `JoinTokenRequest.languages`, and deliberately so: a
        guest's join is

        a join token like any other, and the room's streaming mode decides how
        many languages

        one carries — see `languages_required` on the preview.
    GuestJoinTokenResponse:
      properties:
        room:
          type: string
          title: Room
        token:
          type: string
          title: Token
        url:
          type: string
          title: Url
        languages:
          items:
            $ref: '#/components/schemas/LanguageCode'
          type: array
          title: Languages
        identity:
          type: string
          title: Identity
          description: >-
            Who this guest appears as in the room, and how their connection is
            attributed in the room's usage breakdown. Assigned by the server,
            not chosen: a guest is unauthenticated, so letting them name
            themselves would let them join as anyone.
      type: object
      required:
        - room
        - token
        - url
        - languages
        - identity
      title: GuestJoinTokenResponse
      description: >-
        Credentials for a guest who redeemed an invite link.


        The same shape every other participant gets, plus the `identity` they
        were assigned.

        Connect to `url` with `token`; the token is short-lived and the guest is
        disconnected

        when it expires.


        Redeeming spends one of the link's uses, so this response is not
        repeatable — a

        guest who reloads and joins again consumes another.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    LanguageCode:
      type: string
      enum:
        - ar-EG
        - ca-ES
        - da-DK
        - de-DE
        - el-GR
        - en-GB
        - es-ES
        - fi-FI
        - fr-FR
        - he-IL
        - hi-IN
        - hu-HU
        - it-IT
        - ja-JP
        - ko-KR
        - nl-NL
        - no-NO
        - pl-PL
        - pt-PT
        - ro-RO
        - ru-RU
        - sv-SE
        - tr-TR
        - uk-UA
        - ur-PK
        - zh-CN
      title: LanguageCode
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
        input:
          title: Input
        ctx:
          type: object
          title: Context
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError

````

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