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

# Confirm an adapter address with the code that was emailed to it

> Some credentials are an email address Widgetic sends a widget's messages to (`confirmation: email_code` in
`getUserAdapterConnections`). Saving one with `setUserAdapterConnection` emails a six-digit code to it; this gives
the code back. Only then is the address used: until it is confirmed, the widgets that need it are not charged and
their visitors are told the feature is unavailable.

The code works for 30 minutes and for five wrong tries. After that, save the address again and a new code is
emailed (not sooner than a minute after the last one). A code that is not made of digits is refused without
counting as a try.

Confirming an address that is already confirmed answers 200 with the same state, so a retry of a request that
went through is harmless. Saving a different address, or the same one before it was confirmed, starts again.

This needs an API key with full access. The caller must be the account itself or a Widgetic administrator.




## OpenAPI

````yaml /openapi/widgetic-api-public.json post /users/{userId}/adapter-connections/{adapterId}/{credentialKey}/confirm
openapi: 3.0.0
info:
  title: Widgetic API Gateway
  version: 1.0.0
  description: API documentation for the Widgetic API Gateway
  license:
    name: Widgetic Integration License
    url: https://docs.widgetic.com/resources/license
servers:
  - url: https://api.widgetic.com/v1
    description: Production server
    variables:
      env:
        default: production
        description: Environment
      apiUrl:
        default: https://api.widgetic.com
        description: API URL
      apiVersion:
        default: /v1
        description: API Version path prefix
security: []
tags: []
paths:
  /users/{userId}/adapter-connections/{adapterId}/{credentialKey}/confirm:
    post:
      tags:
        - Users
      summary: Confirm an adapter address with the code that was emailed to it
      description: >
        Some credentials are an email address Widgetic sends a widget's messages
        to (`confirmation: email_code` in

        `getUserAdapterConnections`). Saving one with `setUserAdapterConnection`
        emails a six-digit code to it; this gives

        the code back. Only then is the address used: until it is confirmed, the
        widgets that need it are not charged and

        their visitors are told the feature is unavailable.


        The code works for 30 minutes and for five wrong tries. After that, save
        the address again and a new code is

        emailed (not sooner than a minute after the last one). A code that is
        not made of digits is refused without

        counting as a try.


        Confirming an address that is already confirmed answers 200 with the
        same state, so a retry of a request that

        went through is harmless. Saving a different address, or the same one
        before it was confirmed, starts again.


        This needs an API key with full access. The caller must be the account
        itself or a Widgetic administrator.
      operationId: confirmUserAdapterConnection
      parameters:
        - in: path
          name: userId
          required: true
          schema:
            type: string
            format: uuid
          description: The account that keeps the address. For your own, your own user id
        - in: path
          name: adapterId
          required: true
          schema:
            type: string
            maxLength: 40
          description: The adapter the address is for
        - in: path
          name: credentialKey
          required: true
          schema:
            type: string
            maxLength: 40
          description: The credential's name within the adapter
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ConfirmAdapterConnectionRequest'
      responses:
        '200':
          description: The address is confirmed (or was already)
          content:
            application/json:
              schema:
                title: AdapterConnectionResponse
                type: object
                properties:
                  success:
                    type: boolean
                  data:
                    $ref: '#/components/schemas/AdapterConnection'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
                required:
                  - success
                  - data
        '400':
          description: >-
            A path value or the body is malformed. The body takes exactly one
            field, `code`
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: The API key is missing or invalid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: >-
            The address belongs to another account, or the API key has not full
            access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: >-
            There is no such adapter or credential, an owner may not keep it,
            the credential needs no confirmation, or nothing is connected under
            that name (ADAPTER_NOT_FOUND, CREDENTIAL_NOT_FOUND,
            CREDENTIAL_NOT_FOR_THIS_ACCOUNT, CONFIRMATION_NOT_NEEDED,
            CREDENTIAL_NOT_CONNECTED)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '409':
          description: >-
            No code is waiting for the address (CONFIRMATION_NO_CODE_WAITING),
            or another attempt is being checked, or the address was saved again
            while this one was checked (CONFIRMATION_BUSY). Save the address
            again, or retry
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '422':
          description: >-
            The code is not made of digits (CONFIRMATION_CODE_INVALID), is not
            the one emailed (CONFIRMATION_CODE_WRONG; it counts as a try) or is
            too old (CONFIRMATION_CODE_EXPIRED)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: >-
            Too many changes in a short time (try again after the Retry-After
            seconds), or five wrong codes were given and the code is dead
            (CONFIRMATION_TOO_MANY_ATTEMPTS): save the address again for a new
            one
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          description: >-
            Adapter keys cannot be changed on this server right now
            (ADAPTER_CONNECTIONS_UNAVAILABLE). Nothing was changed
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
      x-code-samples:
        - lang: TypeScript
          label: TypeScript SDK
          source: >
            import { Configuration, UsersApi } from '@widgetic/api-sdk-ts';


            const usersApi = new UsersApi(new Configuration({ apiKey:
            'YOUR_API_KEY' }));


            // After setUserAdapterConnection emailed a code to the address:

            const { data: connection } = await
            usersApi.confirmUserAdapterConnection({
              userId,
              adapterId: 'email',
              credentialKey: 'recipient',
              confirmAdapterConnectionRequest: { code: '123456' },
            });

            console.log(connection.awaitingConfirmation,
            connection.confirmedAt);
components:
  schemas:
    ConfirmAdapterConnectionRequest:
      type: object
      required:
        - code
      additionalProperties: false
      properties:
        code:
          type: string
          maxLength: 32
          description: >-
            The digits of the code Widgetic emailed to the address, with nothing
            else. It works for 30 minutes and for five wrong tries; after that,
            save the address again and a new code is emailed
          example: '123456'
      example:
        code: '123456'
    AdapterConnection:
      type: object
      description: >-
        A key an adapter can take from an account, and whether the account has
        connected it. The key itself is never part of this: it is given once,
        when it is connected, and Widgetic keeps it encrypted.
      required:
        - adapterId
        - adapterLabel
        - credentialKey
        - label
        - scope
        - connected
        - updatedAt
        - confirmation
        - awaitingConfirmation
        - confirmedAt
      properties:
        adapterId:
          type: string
          description: The adapter the key is for (its id in the adapter catalog)
          example: email
        adapterLabel:
          type: string
          description: What the adapter is called to its owner
          example: Email
        credentialKey:
          type: string
          description: >-
            The name of the key within the adapter. Use it, with the adapter id,
            to connect or remove the key
          example: resendApiKey
        label:
          type: string
          description: What the key is called to its owner
          example: Resend API key
        scope:
          type: string
          enum:
            - owner
            - partner
            - owner_or_partner
          description: >-
            Who may keep this key. `owner` is the person who made the widget, in
            their own account. `partner` is a partner, for the widgets of the
            customers it manages. `owner_or_partner` is either; for a widget of
            a managed customer the partner's key is used.
        connected:
          type: boolean
          description: Whether this account has connected the key
        updatedAt:
          type: string
          format: date-time
          nullable: true
          description: When the key was last set. Null when it is not connected
        confirmation:
          type: string
          nullable: true
          description: >-
            How this credential is proved before it is used. `email_code` means
            it is an email address: saving it emails a code to it, and it is
            used only after the code is given back
            (`confirmUserAdapterConnection`, `confirmPartnerAdapterConnection`).
            Null for a credential that is used as soon as it is saved
          example: email_code
        awaitingConfirmation:
          type: boolean
          description: >-
            True when the credential is connected but has not been confirmed
            yet, so no adapter uses it. Always false when `confirmation` is null
            or the credential is not connected
        confirmedAt:
          type: string
          format: date-time
          nullable: true
          description: >-
            When the credential was confirmed. Null when it is not connected, is
            awaiting its code, or needs no confirmation
      example:
        adapterId: email
        adapterLabel: Email
        credentialKey: resendApiKey
        label: Resend API key
        scope: Example scope
        connected: true
        updatedAt: '2026-01-15T09:30:00.000Z'
        confirmation: email_code
        awaitingConfirmation: true
        confirmedAt: '2026-01-15T09:30:00.000Z'
    ResponseMeta:
      type: object
      description: >-
        Extra information about the answer: where a page sits in a list, the
        cursor of the next page, or warnings about a call that succeeded with a
        caveat.
      additionalProperties: true
      properties:
        page:
          type: integer
          description: The page that was read, counting from 1.
          example: 1
        size:
          type: integer
          description: How many items one page holds.
          example: 20
        total:
          type: integer
          description: How many items the whole list has.
          example: 135
        limit:
          type: integer
          description: The same as `size`.
          example: 20
        offset:
          type: integer
          description: How many items come before this page.
          example: 0
        hasNextPage:
          type: boolean
          example: true
        hasPreviousPage:
          type: boolean
          example: false
        nextCursor:
          type: string
          nullable: true
          description: >-
            Pass this as `cursor` to read the next page of a list that is read
            by cursor. `null` on the last page.
        warnings:
          type: array
          items:
            type: string
          description: >-
            Things the call did not do, though it succeeded (for example a table
            that could not be created just now).
    ErrorResponse:
      type: object
      required:
        - success
        - message
        - error
      additionalProperties: true
      properties:
        success:
          type: boolean
          description: Always `false` on a failure.
          example: false
        message:
          type: string
          description: The same text as `error.message`, for a caller that reads one line.
        error:
          $ref: '#/components/schemas/ErrorDetail'
    ErrorDetail:
      type: object
      required:
        - code
        - message
        - timestamp
      properties:
        code:
          type: string
          description: Machine-readable error code.
          example: RESOURCE_NOT_FOUND
        message:
          type: string
          description: Human-readable explanation.
          example: Composition not found
        param:
          type: string
          description: The field that caused the error, when one did.
          example: name
        docUrl:
          type: string
          description: Where this error is explained.
        suggestedAction:
          type: string
          description: What to do about it.
        retryAfter:
          type: integer
          description: >-
            Seconds to wait before trying again (rate limits). The same number
            is in the `Retry-After` header.
          example: 60
        details:
          type: object
          additionalProperties: true
          description: >-
            More about the error: the fields that failed, a limit that was
            reached.
        correlationId:
          type: string
          description: Quote this when you ask support about the call.
          example: req_123e4567-e89b-12d3-a456-426614174000
        timestamp:
          type: string
          format: date-time
          example: '2026-10-15T10:00:00.000Z'
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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