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

> ## Agent Instructions
> Internal links on these pages omit the .md extension. Append .md to a docs page URL, or send an Accept: text/markdown header, to get that page as markdown.

# Get Wix Payments status

> <Info>This API is in beta. Endpoints, fields, and behavior may still change, so avoid depending on it in production.</Info>

Reports whether Wix Payments is connected to the app, and if it isn't, whether you can connect it now.

Use it to check a connection before taking payments. Wix reports account changes, such as a finished verification, in the background, so read the status again rather than relying on an earlier answer.

When Wix Payments can't be connected, `connect_blocker` names the first reason. Clear it and read the status again, since a second reason can show up once the first is gone.

<Note>This endpoint only reads, but it needs write access to the app and a personal access token set to Full access. A viewer is refused, and so is a read-only token. The app's workspace also has to allow payment management.</Note>



## OpenAPI

````yaml /developers/references/app-management/app-management-openapi.json get /api/apps/{app_id}/payments/wix/status
openapi: 3.1.0
info:
  title: Base44 App Management API
  version: 1.0.0
servers:
  - url: https://app.base44.com
security:
  - PersonalAccessTokenAuth: []
paths:
  /api/apps/{app_id}/payments/wix/status:
    get:
      summary: Get Wix Payments status
      description: >-
        <Info>This API is in beta. Endpoints, fields, and behavior may still
        change, so avoid depending on it in production.</Info>


        Reports whether Wix Payments is connected to the app, and if it isn't,
        whether you can connect it now.


        Use it to check a connection before taking payments. Wix reports account
        changes, such as a finished verification, in the background, so read the
        status again rather than relying on an earlier answer.


        When Wix Payments can't be connected, `connect_blocker` names the first
        reason. Clear it and read the status again, since a second reason can
        show up once the first is gone.


        <Note>This endpoint only reads, but it needs write access to the app and
        a personal access token set to Full access. A viewer is refused, and so
        is a read-only token. The app's workspace also has to allow payment
        management.</Note>
      operationId: get_wix_payments_status_api_apps__app_id__payments_wix_status_get
      parameters:
        - name: app_id
          in: path
          required: true
          schema:
            type: string
            description: ID of the Base44 app.
            title: App Id
          description: ID of the Base44 app.
          example: 6820f3a4e7b91d003c45a1f2
      responses:
        '200':
          description: >-
            The app's Wix Payments connection, and whether it can be connected
            when it isn't.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WixPaymentsStatus'
        '401':
          description: Missing or invalid credentials.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
        '403':
          description: >-
            You don't have write access to the app, or your personal access
            token is read-only (`forbidden`). Also returned when the app's
            workspace doesn't allow payment management
            (`app_payment_management_not_allowed`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
        '404':
          description: >-
            The app isn't found, or it's outside the credential's grant
            (`not_found`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
        '409':
          description: The workspace requires an unlocked SSO session.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
        '429':
          description: >-
            Rate limit reached (`rate_limited`). The base limit is 60 requests
            per minute per user. A successful response reports the budget in
            `X-RateLimit-Limit`, `X-RateLimit-Remaining`, and
            `X-RateLimit-Reset` (Unix seconds), and a rate-limited one adds
            `Retry-After`. See [Rate
            limits](/developers/references/apps-api/get-started/rate-limits) for
            the multiplier your plan gets.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardErrorEnvelope'
      security:
        - PersonalAccessTokenAuth:
            - full_access
components:
  schemas:
    WixPaymentsStatus:
      properties:
        connected:
          type: boolean
          title: Connected
          description: >-
            Whether Wix Payments is connected to the app (`true`) or not
            (`false`).
          example: false
        test_mode:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Test Mode
          description: >-
            Whether the checkout takes test payments (`true`) or real ones
            (`false`), or `null` when Wix Payments isn't connected or the mode
            was never recorded.
        account:
          anyOf:
            - $ref: '#/components/schemas/WixPaymentsAccount'
            - type: 'null'
          description: >-
            The Wix Payments account's state, or `null` when Wix Payments isn't
            connected or Wix hasn't reported the account's status yet.
        can_connect:
          type: boolean
          title: Can Connect
          description: >-
            Whether you can connect Wix Payments now (`true`) or not (`false`).
            Only the app owner can connect, so anyone else gets `false`. It's
            also `false` once Wix Payments is connected.
          example: false
        connect_blocker:
          anyOf:
            - $ref: '#/components/schemas/WixPaymentsConnectBlocker'
            - type: 'null'
          description: >-
            The first reason Wix Payments can't be connected, or `null` when
            it's connected or can be connected.
          example:
            code: checkout_already_owned
            message: A payment integration is already set up for this app.
      type: object
      required:
        - connected
        - test_mode
        - account
        - can_connect
        - connect_blocker
      title: WixPaymentsStatus
    StandardErrorEnvelope:
      properties:
        error:
          $ref: '#/components/schemas/StandardError'
          description: What went wrong.
      type: object
      required:
        - error
      title: StandardErrorEnvelope
      description: The error body returned in the standard envelope.
    WixPaymentsAccount:
      properties:
        can_accept_payins:
          type: boolean
          title: Can Accept Payins
          description: >-
            Whether the account can take payments from the app's customers
            (`true`) or Wix Payments still limits them (`false`).
          example: false
        can_receive_payouts:
          type: boolean
          title: Can Receive Payouts
          description: >-
            Whether Wix Payments can pay funds out to the account (`true`) or
            holds payouts (`false`).
          example: true
        status:
          type: string
          title: Status
          description: >-
            The account status Wix Payments reports, in snake_case, for example
            `pending` while the account is under review.
          example: pending
        reason:
          anyOf:
            - type: string
            - type: 'null'
          title: Reason
          description: >-
            Why Wix Payments limits payments on the account, in snake_case, for
            example `verification_not_started`, or `null` when the account can
            take payments.
          example: verification_not_started
        updated_at:
          type: string
          format: date-time
          title: Updated At
          description: >-
            When Base44 last recorded the account status, as a UTC timestamp in
            ISO 8601 format.
          example: '2026-01-15T09:23:41Z'
      type: object
      required:
        - can_accept_payins
        - can_receive_payouts
        - status
        - reason
        - updated_at
      title: WixPaymentsAccount
    WixPaymentsConnectBlocker:
      properties:
        code:
          type: string
          title: Code
          description: >-
            Why Wix Payments can't be connected. It's `not_app_owner`,
            `checkout_already_owned`, `backend_functions_not_available`, or
            `wix_payments_not_available`.
          example: checkout_already_owned
        message:
          type: string
          title: Message
          description: >-
            A human-readable explanation of the reason. Branch on `code`, since
            the wording can change.
          example: A payment integration is already set up for this app.
      type: object
      required:
        - code
        - message
      title: WixPaymentsConnectBlocker
    StandardError:
      properties:
        code:
          type: string
          title: Code
          description: >-
            Stable machine-readable cause of the failure. Match on this, not on
            `message`.
          example: not_found
        message:
          type: string
          title: Message
          description: Human-readable explanation. It isn't a stable contract.
          example: App not found
        details:
          additionalProperties: true
          type: object
          title: Details
          description: >-
            Structured context for the failure, or an empty object when there's
            none.
          example: {}
      type: object
      required:
        - code
        - message
      title: StandardError
  securitySchemes:
    PersonalAccessTokenAuth:
      type: http
      scheme: bearer
      description: >-
        Personal access token, sent as `Authorization: Bearer <token>`. Each
        operation lists the permission it needs: `read_only` or `full_access`. A
        full-access token can call every operation. A read-only token can call
        only the operations that list `read_only`; anything else returns 403
        `read_only_credential_route_not_allowed`.

````

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