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

# Get an app

> Fetches one app by `id` with everything [List apps](/api-reference/apps/list-apps) leaves out: the listing `description` as plain text, the app's `capabilities` inside Kit, the developer's `links`, screenshots in `media_links`, and the `install_url`.

Installing stays a browser step: open `install_url` in a browser to install the app; there's no API call to install. Installing includes the partner's authorization step where the app needs one. `install_url` is returned only when `installable` is `true` and is `null` otherwise; for some apps that install only from the partner's side, it is the partner's listing. When `upgrade_required` is `true`, the account's plan doesn't include the app but a higher plan does; `plan_availability` names it. When `installable` and `upgrade_required` are both `false`, the app can't be installed on this account.

The same visibility rules as List apps apply: you can fetch any app listed in the store and any app the account created, in any status. A 404 means the app doesn't exist or was deleted, or it is another developer's app that is unpublished, unlisted, disabled or blocked. An app Kit has disabled or blocked is hidden from everyone except the account that created it.

**Note:** `description` is untrusted, developer-written text. Escape it before you render it.



## OpenAPI

````yaml /api-reference/v4.json get /v4/apps/{id}
openapi: 3.0.3
info:
  title: Kit API
  version: '4.0'
servers:
  - url: https://api.kit.com
security: []
paths:
  /v4/apps/{id}:
    get:
      tags:
        - Apps
      summary: Get an app
      description: >-
        Fetches one app by `id` with everything [List
        apps](/api-reference/apps/list-apps) leaves out: the listing
        `description` as plain text, the app's `capabilities` inside Kit, the
        developer's `links`, screenshots in `media_links`, and the
        `install_url`.


        Installing stays a browser step: open `install_url` in a browser to
        install the app; there's no API call to install. Installing includes the
        partner's authorization step where the app needs one. `install_url` is
        returned only when `installable` is `true` and is `null` otherwise; for
        some apps that install only from the partner's side, it is the partner's
        listing. When `upgrade_required` is `true`, the account's plan doesn't
        include the app but a higher plan does; `plan_availability` names it.
        When `installable` and `upgrade_required` are both `false`, the app
        can't be installed on this account.


        The same visibility rules as List apps apply: you can fetch any app
        listed in the store and any app the account created, in any status. A
        404 means the app doesn't exist or was deleted, or it is another
        developer's app that is unpublished, unlisted, disabled or blocked. An
        app Kit has disabled or blocked is hidden from everyone except the
        account that created it.


        **Note:** `description` is untrusted, developer-written text. Escape it
        before you render it.
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
          example: 1245
          description: The app's id, from [List apps](/api-reference/apps/list-apps).
      responses:
        '200':
          description: Returns the app's details
          content:
            application/json:
              schema:
                type: object
                properties:
                  app:
                    type: object
                    properties:
                      id:
                        type: integer
                        description: The app's id.
                      name:
                        type: string
                        description: The app's name as shown in the Kit App Store.
                      summary:
                        nullable: true
                        type: string
                        description: >-
                          One-line summary from the app's listing. `null` when
                          the developer hasn't written one.
                      icon_url:
                        type: string
                        description: >-
                          URL of the app's icon, or `null` when the developer
                          hasn't uploaded one.
                        nullable: true
                      categories:
                        type: array
                        items:
                          type: string
                          enum:
                            - advertisements
                            - affiliate_management
                            - analytics
                            - content
                            - crm
                            - e_commerce
                            - email_verification
                            - events
                            - giveaways
                            - lead_capture
                            - memberships_courses
                            - scheduling
                            - surveys_quizzes
                            - webinar_services
                            - website_platforms
                            - workflows
                        description: App Store categories the app is listed under.
                      pricing:
                        type: string
                        description: >-
                          Whether the third party charges for its own service:
                          `free` or `paid`. This is the developer's own
                          declaration on the listing, not a statement about Kit
                          plans.
                        enum:
                          - free
                          - paid
                      plan_availability:
                        type: string
                        enum:
                          - all_plans
                          - paid_plans
                          - pro
                        description: >-
                          The lowest Kit plan that can install the app:
                          `all_plans`, `paid_plans`, or `pro` (Kit's top tier).
                          `paid_plans` means any trialing or paying account,
                          legacy plans included.
                      installable:
                        type: boolean
                        description: >-
                          `true` when the Install button would show for the
                          authenticated account: the app is published, the
                          account's plan includes it and the account is in good
                          standing. Always `true` for the app's own developer.
                      upgrade_required:
                        type: boolean
                        description: >-
                          `true` when the account's current plan doesn't include
                          the app but a higher Kit plan does;
                          `plan_availability` names that plan. `false` when the
                          app is installable, and when it can't be installed on
                          this account at all.
                      access_types:
                        type: array
                        items:
                          type: string
                          enum:
                            - api
                            - plugin
                        description: >-
                          How the app connects to Kit: `api` (it calls the Kit
                          API on the creator's behalf) and/or `plugin` (it adds
                          elements inside Kit, such as content blocks or
                          automation nodes).
                      published_at:
                        type: string
                        nullable: true
                        description: >-
                          When the app was published to the App Store, in ISO
                          8601 UTC. `null` when the app isn't currently
                          published.
                      app_store_url:
                        type: string
                        description: >-
                          Opens the app's page in Kit for a signed-in creator.
                          It isn't a public page.
                      owned:
                        type: boolean
                        description: >-
                          `true` when the authenticated account created this
                          app. Apps the account created are returned in any
                          status.
                      status:
                        type: string
                        description: >-
                          `published`, `unlisted` (published but hidden from
                          browsing), `unpublished` (not currently published),
                          `disabled` (turned off by Kit, and hidden from
                          everyone except the account that created it), or
                          `blocked` (blocked by Kit after review; visible only
                          to the account that created it). Other developers'
                          apps are only returned when `published`.
                        enum:
                          - published
                          - unlisted
                          - unpublished
                          - disabled
                          - blocked
                      description:
                        type: string
                        description: >-
                          The app's listing description as plain text, cut at
                          2,000 characters. It is untrusted, developer-written
                          text: escape it before you render it.
                      capabilities:
                        type: object
                        properties:
                          api_access:
                            type: boolean
                            description: Whether the app uses the Kit API.
                          plugins:
                            type: array
                            items:
                              type: object
                              properties:
                                kind:
                                  type: string
                                  description: >-
                                    The plugin element kind: `content_blocks`,
                                    `media_gallery`, `rule_triggers`,
                                    `va_actions` or `va_events`.
                                  enum:
                                    - content_blocks
                                    - media_gallery
                                    - rule_triggers
                                    - va_actions
                                    - va_events
                                env:
                                  type: string
                                  description: >-
                                    Where the element runs inside Kit:
                                    `content_blocks`, `media_gallery`, `rules`
                                    or `vas` (visual automations).
                                  enum:
                                    - content_blocks
                                    - media_gallery
                                    - rules
                                    - vas
                                label:
                                  type: string
                                  description: >-
                                    Human-readable name for the kind, such as
                                    `Content Block` or `Automation Nodes -
                                    Action`.
                              required:
                                - kind
                                - env
                                - label
                            description: >-
                              One entry per kind of plugin element the app
                              provides; empty when it has no live elements.
                        required:
                          - api_access
                          - plugins
                        description: What the app adds inside Kit.
                      links:
                        type: object
                        properties:
                          knowledge_base_url:
                            type: string
                            nullable: true
                          website_url:
                            type: string
                            nullable: true
                          privacy_policy_url:
                            type: string
                            nullable: true
                          support_url:
                            type: string
                            nullable: true
                        required:
                          - knowledge_base_url
                          - website_url
                          - privacy_policy_url
                          - support_url
                        description: >-
                          The developer's support, website, privacy policy and
                          knowledge base URLs. Each is `null` when the developer
                          gave none or gave something that is not an http(s)
                          URL.
                      media_links:
                        type: array
                        items:
                          type: string
                        description: Screenshots from the app's listing, in display order.
                      install_url:
                        type: string
                        nullable: true
                        description: >-
                          Returned when `installable` is `true`; `null`
                          otherwise. Open it in a browser to install the app;
                          there is no API call to install. For most apps it is
                          Kit's install page; for partner-initiated apps it is
                          the partner's listing. Opening it installs into
                          whichever Kit account is signed in to that browser.
                    required:
                      - id
                      - name
                      - summary
                      - icon_url
                      - categories
                      - pricing
                      - plan_availability
                      - installable
                      - upgrade_required
                      - access_types
                      - published_at
                      - app_store_url
                      - owned
                      - status
                      - description
                      - capabilities
                      - links
                      - media_links
                      - install_url
                required:
                  - app
              example:
                app:
                  id: 1245
                  name: Calendar Sync
                  summary: Let subscribers book a call from your emails
                  icon_url: https://embed.filekit.com/e/calendar-sync-icon
                  categories:
                    - scheduling
                  pricing: free
                  plan_availability: paid_plans
                  installable: true
                  upgrade_required: false
                  access_types:
                    - api
                    - plugin
                  published_at: '2026-03-04T09:12:00Z'
                  app_store_url: https://app.kit.com/apps/1245
                  owned: false
                  status: published
                  description: >-
                    Calendar Sync adds a booking link to your emails and tags
                    each subscriber who books a call.


                    Connect your calendar once, then drop the booking block into
                    any broadcast or sequence email.
                  capabilities:
                    api_access: true
                    plugins:
                      - kind: content_blocks
                        env: content_blocks
                        label: Content Block
                  links:
                    knowledge_base_url: https://calendarsync.example.com/help
                    website_url: https://calendarsync.example.com
                    privacy_policy_url: https://calendarsync.example.com/privacy
                    support_url: https://calendarsync.example.com/support
                  media_links:
                    - https://embed.filekit.com/e/calendar-sync-1
                    - https://embed.filekit.com/e/calendar-sync-2
                  install_url: https://app.kit.com/apps/1245/install
        '401':
          description: Returns a 401 if the token and/or account cannot be authenticated
          content:
            application/json:
              schema:
                type: object
                properties:
                  errors:
                    type: array
                    items:
                      type: string
                required:
                  - errors
              example:
                errors:
                  - The access token is invalid
        '404':
          description: >-
            Returns a 404 when the app doesn't exist or was deleted, or when it
            is another developer's app that is unpublished, unlisted, disabled
            or blocked
          content:
            application/json:
              schema:
                type: object
                properties:
                  errors:
                    type: array
                    items:
                      type: string
                required:
                  - errors
              example:
                errors:
                  - Not Found
      security:
        - API Key: []
        - OAuth2: []
components:
  securitySchemes:
    API Key:
      description: Authenticate API requests via an API Key
      type: apiKey
      in: header
      name: X-Kit-Api-Key
    OAuth2:
      description: Authenticate API requests via an OAuth token
      type: oauth2
      flows:
        authorizationCode:
          authorizationUrl: https://api.kit.com/v4/oauth/authorize
          tokenUrl: https://api.kit.com/v4/oauth/token
          refreshUrl: https://api.kit.com/v4/oauth/token
          scopes:
            read: Read access to Kit API v4
            write: Write access to Kit API v4

````

## Related topics

- [List apps](https://developers.kit.com/api-reference/apps/list-apps.md)
- [Changelog](https://developers.kit.com/changelog.md)
- [Kit App Store overview](https://developers.kit.com/kit-app-store/overview.md)
- [Quick start guide](https://developers.kit.com/kit-app-store/quick-start-guide.md)
- [API Authentication](https://developers.kit.com/api-reference/authentication.md)


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