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

# Create App

> Registers a new app on the Whop developer platform. Apps provide custom experiences that can be added to products.



## OpenAPI

````yaml /openapi/api-v1-native.json post /apps
openapi: 3.1.0
info:
  description: >-
    The Whop REST API. Please see
    https://docs.whop.com/developer/api/getting-started for more details.
  termsOfService: https://whop.com/tos-developer-api/
  title: Whop API
  version: 1.0.0
  x-api-version-date: '2026-07-20'
servers:
  - description: Production Whop API
    url: https://api.whop.com/api/v1
  - description: Sandbox Whop API
    url: https://sandbox-api.whop.com/api/v1
security: []
tags:
  - description: >
      An Account represents a person or business on Whop that can have its own
      profile, wallet, and account-scoped settings. Use accounts for customers,
      creators, merchants, sellers, or connected businesses your integration
      supports.


      Use the Accounts API to create accounts, list accounts visible to your
      credentials, retrieve or update an account, and retrieve the account
      associated with the current API key.
    name: Accounts
    x-whop-summary: 'A business on Whop: profile, wallet, capabilities, settings.'
  - description: >
      A User represents a person on Whop. Users have a public profile and can
      buy products, join accounts, and access experiences.


      Use the Users API to search for users, retrieve or update profiles, and
      check whether a user has access to an account, product, or experience.
    name: Users
    x-whop-summary: 'A person on Whop: profile and connected identities.'
  - description: >
      A Team Member is a member of an account's team: the link between a user
      and an account, carrying the role that controls what they can do. Roles
      are either system roles (like `admin` or `moderator`) or `custom` roles
      managed from the dashboard.


      Use the Team Members API to list an account's team, add a user to the team
      with a system role, change a member's role, and remove members. Adding a
      user who has not yet accepted sends an invitation instead.
    name: Team Members
    x-whop-summary: An account's team members and the roles that scope their access.
  - name: Webhooks
    x-whop-summary: Event notifications pushed to your server as things happen.
  - description: >
      Stats represent aggregated activity for an account over time. They help
      you understand revenue, transactions, disputes, members, referrals, and
      advertising performance across reporting periods like days, weeks, or
      months.


      Use the Stats API to list available metrics and their filterable
      properties, then retrieve time-series values for a date range.
    name: Stats
    x-whop-summary: Aggregated financial, audience, and traffic reporting.
  - description: >
      A Ledger Activity row is a single financial event on an account's ledger —
      a payment, withdrawal, refund, transfer, on-chain deposit, swap, or card
      transaction. Each row is derived from the underlying ledger lines and
      carries a typed `resource` and `source` so you can present and link the
      event without extra lookups.


      Use Ledger Activity to build a statement or transaction feed for an
      account or user. Reconcile against your own records with `amount` (signed,
      in the currency's smallest precision units) and `posted_at`, and use
      `available_at` to know when inflows became withdrawable.
    name: Ledgers
    x-whop-summary: The activity feed behind an account or user's balance.
  - description: >
      Payouts represent money sent from an account or user balance to an
      external destination, such as a bank account, wallet, or other saved
      payout method.


      Use the Payouts API to create payouts from stablecoin accounts, list
      payout history for accounts or users, monitor payout statuses, and show
      expected arrival details for funds leaving Whop.
    name: Payouts
    x-whop-summary: Send money from a balance to a bank or wallet.
  - description: >
      Cards represent Whop-issued virtual payment cards that spend from an
      account or user balance. Cards can be assigned to cardholders and
      configured with spending limits for controlled spending.


      Use the Cards API to issue cards, list cards for an account or user, and
      retrieve active card details such as the card number and CVC.
    name: Cards
    x-whop-summary: Issue cards that spend from a balance.
  - description: >
      Transfers move value between identities on Whop. They are used for
      account-to-account money movement, user payouts inside Whop, crypto
      transfers, and claim links depending on the destination type.


      Use the Transfers API to create a transfer, list previous transfers, and
      retrieve a transfer by ID when reconciling money movement between accounts
      or users.
    name: Transfers
    x-whop-summary: Move funds between Whop accounts and users.
  - description: >
      Deposits describe ways to add funds to an account balance, including
      hosted deposit pages, bank deposit instructions, and supported crypto
      wallet addresses.


      Use the Deposits API to create deposit instructions for an account.
    name: Deposits
    x-whop-summary: Add funds to a balance.
  - description: >
      Swaps convert value between supported tokens, chains, or wallet
      destinations for an account. A swap quote describes the expected output,
      fees, and approval requirements before you create the swap.


      Use the Swaps API to quote a conversion, create the swap, list recent
      swaps, and retrieve status until the transaction completes.
    name: Swaps
    x-whop-summary: Convert a balance between currencies.
  - description: >
      A Verification represents a legal identity for a person or business.
      Accounts and users complete verification when Whop needs to confirm who
      they are before enabling payouts or compliance-sensitive workflows.


      Use the Verifications API to start or resume a hosted verification
      session, check review status, and submit requested details or documents.
      If `requested_information` contains items, submit answers with [Update
      Verification](/api-reference/beta/verifications/update-verification).
    name: Verifications
    x-whop-summary: Legal identity required before payouts and card issuing.
  - description: >
      A Product is a digital good or service sold on Whop. Products may contain
      plans for pricing and/or experiences for content delivery.


      Use the Products API to create products, list products visible to your
      credentials, retrieve product details, update product metadata or
      merchandising fields, and delete products that should no longer be sold.
    name: Products
    x-whop-summary: The things you sell. Each owns plans and a store page.
  - description: >
      A Plan defines how customers buy a product. It controls pricing, billing
      cadence, availability, tax behavior, checkout fields, and purchase
      visibility.


      Use the Plans API to create plans for products, list existing plans,
      retrieve or update plan configuration, calculate tax for checkout, and
      delete plans that should no longer be offered.
    name: Plans
    x-whop-summary: 'Pricing for a product: one-time, recurring, trials, stock.'
  - description: >
      A Checkout Configuration is a reusable checkout link owned by an account.
      In `payment` mode it sells a specific plan; in `setup` mode it collects
      and saves payment details without charging. Each configuration can also
      override which payment methods are accepted and how 3D Secure is enforced
      for that checkout.


      Use the Checkout Configurations API to create checkout links for an
      existing or inline plan, list configurations for an account, retrieve the
      configuration behind a checkout URL, and delete links that should no
      longer be used.
    name: Checkout Configurations
    x-whop-summary: Turn a plan into a shareable, prefilled checkout link.
  - description: >
      The Partners API covers your Whop partner activity: the users you referred
      onto Whop, the businesses you referred and the earnings generated from
      their processing volume, and the partner leaderboard.


      Use it to enroll as a Whop partner, list the users you referred, list your
      referred businesses and review their earnings, and see the partner
      leaderboard.
    name: Partners
    x-whop-summary: >-
      The users and businesses you referred to Whop, and what you earn from
      them.
  - description: >
      A Bounty is a paid task posted by an account or user. The reward is held
      in escrow when the bounty publishes, workers submit proof of completed
      work, and each accepted submission is paid out until every winner slot
      fills.


      Use the Bounties API to create and publish a bounty, list an account's
      bounties for reporting or dashboards, list the bounties a user can work or
      has participated in, and retrieve a single bounty by ID.
    name: Bounties
    x-whop-summary: Paid tasks with reviewed submissions and escrowed rewards.
  - description: >
      A Bounty Submission is one worker's attempt on a bounty. It starts as an
      in-progress attempt, enters the review queue when proof is submitted, and
      ends approved (paid from the bounty's escrowed pool) or denied.


      Use the Bounty Submissions API to submit proof of completed work to a
      bounty, list the submissions you authored, and review the submissions on
      your bounties — across every bounty or narrowed to one.
    name: Bounty Submissions
    x-whop-summary: Work submitted to a bounty, from attempt to payout.
  - description: >
      A Person represents a visitor or customer of an account, assembled from
      [pixel events](/api-reference/beta/events/event) and purchase activity —
      ad clicks, storefront visits, and checkouts.


      Use the People API to list the people of an account and retrieve a single
      person.
    name: People
    x-whop-summary: Visitors and customers of an account, aggregated from pixel events.
  - description: >
      An Event records conversion or engagement activity for an account, such as
      page views, purchases, or leads. Each event ties the action to the
      [person](/api-reference/beta/people/person) who took it, so activity can
      be attributed to the ads and links that drove it.


      Use the Events API to send new tracking events, list recent
      identity-linked events for an account, and inspect the events recorded for
      a person.
    name: Events
    x-whop-summary: Conversion and engagement events tracked for attribution.
  - description: >
      An Ad is the individual creative unit delivered by an [ad
      group](/api-reference/beta/ad-groups/ad-group). It holds the copy,
      creative assets, and destination URL for one ad.


      Use the Ads API to list ads for an account, create ads inside ad groups,
      retrieve or update creative details, delete ads that should stop running,
      and pause or resume delivery.
    name: Ads
    x-whop-summary: 'The creative: copy, assets, and destination URL.'
  - description: >
      An Ad Campaign is the top-level container for paid ads on an ad network.
      It sets the platform, objective, and budget strategy shared by its [ad
      groups](/api-reference/beta/ad-groups/ad-group) and ads.


      Use the Ad Campaigns API to create campaigns, list campaigns for an
      account, retrieve or update campaign settings, and pause or resume
      campaign delivery.
    name: Ad Campaigns
    x-whop-summary: Platform, objective, and budget for a set of ads.
  - description: >
      An Ad Group sits inside an [ad
      campaign](/api-reference/beta/ad-campaigns/ad-campaign) and controls
      delivery for [ads](/api-reference/beta/ads/ad). It sets the audience,
      placements, schedule, budget, and optimization goal for its ads.


      Use the Ad Groups API to create ad groups in campaigns, list or retrieve
      targeting and delivery settings, update budgets or targeting, delete
      groups that should stop running, and pause or resume delivery. It can also
      search the ad platform's targeting taxonomy for options to target and
      estimate how many people a draft targeting spec can reach.
    name: Ad Groups
    x-whop-summary: Audience, placements, and schedule within a campaign.
  - description: >
      An Audience represents a customer list uploaded to Whop for ad targeting.
      Audiences belong to an account and sync to supported ad platforms as
      custom audiences.


      Use the Audiences API to create audiences from CSV uploads, monitor
      processing status, and list or delete audiences for an account. Created
      audiences are usable for targeting after processing reaches `ready` or
      `partial`.
    name: Audiences
    x-whop-summary: Reusable targeting lists for ad groups.
  - description: >
      A Media Asset is an AI-generated image or video created from a prompt and
      billed from an account balance. When generation finishes, the asset
      includes a file that can be attached anywhere Whop accepts files.


      Use the Media API to start a generation job and retrieve the asset while
      it processes or after it is ready.
    name: Media
    x-whop-summary: >-
      AI-generated assets, billed from a balance, attachable wherever files are
      accepted.
  - description: >
      A Social Account represents an external profile connected to a Whop
      account or user, such as a Facebook page or Instagram account. Connecting
      a social account lets Whop run [ads](/api-reference/beta/ads/ad) under
      that profile's identity and promote its existing posts.


      Use the Social Accounts API to list connected accounts, create a
      Whop-managed Facebook page, start an OAuth connection, disconnect a social
      account, and list a connected profile's posts or a Facebook page's lead
      forms.
    name: Social Accounts
    x-whop-summary: Connected Facebook and Instagram accounts that run ads.
  - description: >
      An App is software you build on Whop. It can be a hosted web app served at
      `<route>.whop.app` or an API integration installed as an experience, and
      it belongs to the account that owns its credentials, settings, builds, and
      runtime logs.


      Use the Apps API to manage app configuration and, for hosted apps, read
      server runtime logs for console output, uncaught exceptions, and failed
      requests. Logs are retained for 7 days and can be filtered by build,
      level, time window, and message text.
    name: Apps
    x-whop-summary: 'Apps you build on Whop: metadata, hosted builds, runtime logs.'
  - description: >
      An App Build is a versioned artifact uploaded for an app — a hosted web
      archive, or an iOS/Android bundle. Builds start as drafts, go through
      review, and one approved build per platform is served to users as the
      production build.


      Use the App Builds API to upload a build for an app, list an app's builds
      with platform and status filters, retrieve a build, and promote a draft or
      approved build to production.
    name: App Builds
    x-whop-summary: Versioned build artifacts deployed to an app's platforms.
  - description: >
      An API Key is a programmatic credential owned by an account or app. Each
      key carries its own permissions policy — explicit permission statements or
      an inherited system role — and can be restricted with an expiration date
      and an IP allowlist.


      Use the API Keys API to list a company or app's keys, create a key (the
      full secret is returned once, on creation), inspect a key's effective
      grants, update its name or restrictions, rotate its secret, and revoke it.
      These endpoints require a user session — they cannot be called with an API
      key.
    name: API Keys
    x-whop-summary: Programmatic credentials for an account or app.
paths:
  /apps:
    parameters:
      - $ref: '#/components/parameters/ApiVersionDate'
    post:
      tags:
        - Apps
      summary: Create App
      description: >-
        Registers a new app on the Whop developer platform. Apps provide custom
        experiences that can be added to products.
      operationId: createApp
      parameters:
        - $ref: '#/components/parameters/IdempotencyKey'
      requestBody:
        content:
          application/json:
            schema:
              properties:
                account_id:
                  description: >-
                    The account to create the app for (`biz_` tag). Defaults to
                    the account behind the presented credential.
                  type: string
                base_url:
                  description: >-
                    The base production URL where the app is hosted, such as
                    `https://myapp.example.com`.
                  type:
                    - string
                    - 'null'
                icon:
                  description: >-
                    The icon image for the app in PNG, JPEG, or GIF format,
                    referencing an uploaded file: `{ id }` for an existing
                    attachment or `{ direct_upload_id }` for a new direct
                    upload.
                  properties:
                    direct_upload_id:
                      description: The signed id of a completed direct upload.
                      type: string
                    id:
                      description: The tag of an already-uploaded attachment.
                      type: string
                  type: object
                name:
                  description: >-
                    The display name for the app, shown to users on the app
                    store and product pages.
                  type: string
                redirect_uris:
                  description: >-
                    The whitelisted OAuth callback URLs that users are
                    redirected to after authorizing the app.
                  items:
                    type: string
                  type: array
                route:
                  description: >-
                    The subdomain route where the app's hosted web builds are
                    served, such as `myapp` for myapp.whop.app.
                  type:
                    - string
                    - 'null'
              required:
                - name
              type: object
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/App'
          description: app created
        '400':
          $ref: '#/components/responses/InvalidParameters'
          description: the request body is invalid
        '401':
          $ref: '#/components/responses/Unauthorized'
          description: missing or invalid authentication
        '403':
          $ref: '#/components/responses/Forbidden'
          description: credential lacks the app-creation scope
        '404':
          $ref: '#/components/responses/NotFound'
          description: no company with that ID exists
      security:
        - bearerAuth:
            - developer:create_app
      x-codeSamples:
        - lang: JavaScript
          source: |-
            import Whop from '@whop/sdk';

            const client = new Whop({
              apiKey: process.env['WHOP_API_KEY'], // This is the default and can be omitted
            });

            const app = await client.apps.create({ name: 'name' });

            console.log(app.id);
components:
  parameters:
    ApiVersionDate:
      description: Pins the request to a dated API version.
      in: header
      name: Api-Version-Date
      required: false
      schema:
        example: '2026-07-20'
        type: string
    IdempotencyKey:
      description: >-
        A unique key that makes this request safe to retry. See [Idempotent
        requests](https://docs.whop.com/developer/api/idempotency).
      in: header
      name: Idempotency-Key
      required: false
      schema:
        example: d9105228-4a08-46b1-8b91-42fed586d383
        maxLength: 255
        type: string
  schemas:
    App:
      description: >-
        An app is an integration built on Whop. Apps can serve consumers as
        experiences within products, or serve companies as business tools.
      properties:
        api_key:
          description: >-
            The API key used to authenticate requests on behalf of this app.
            Null if no API key has been generated. Requires the
            'developer:manage_api_key' permission.
          properties:
            created_at:
              description: The datetime the private api key was created.
              example: '2023-12-01T05:00:00.401Z'
              format: date-time
              type: string
            id:
              description: The unique identifier for the private api key.
              type: string
            token:
              description: This is the API key used to authenticate requests
              type: string
          required:
            - id
            - token
            - created_at
          type:
            - object
            - 'null'
        app_type:
          $ref: '#/components/schemas/AppTypes'
          description: >-
            The target audience classification for this app (e.g., 'b2b_app',
            'b2c_app', 'company_app', 'component').
        base_url:
          description: >-
            The production base URL where the app is hosted. Null if no base URL
            is configured.
          example: https://myapp.example.com
          type:
            - string
            - 'null'
        company:
          description: The company that owns and publishes this app.
          properties:
            id:
              description: The unique identifier for the company.
              example: biz_xxxxxxxxxxxxxx
              type: string
            title:
              description: The display name of the company shown to customers.
              example: Pickaxe
              type: string
          required:
            - id
            - title
          type: object
        creator:
          description: The user who created and owns the company that published this app.
          properties:
            id:
              description: The unique identifier for the user.
              example: user_xxxxxxxxxxxxx
              type: string
            name:
              description: The user's display name shown on their public profile.
              example: John Doe
              type:
                - string
                - 'null'
            username:
              description: The user's unique username shown on their public profile.
              example: johndoe42
              type: string
          required:
            - id
            - name
            - username
          type: object
        dashboard_path:
          description: >-
            The URL path template for a specific view of this app, appended to
            the base domain (e.g., '/experiences/[experienceId]'). Null if the
            specified view type is not configured.
          example: /experiences/[experienceId]
          type:
            - string
            - 'null'
        default_api_key:
          description: >-
            The app's default API key, used to authenticate requests on behalf
            of this app. Null if the app has no default key. Requires the
            'developer:manage_api_key' permission.
          properties:
            id:
              description: The unique identifier for the authorized api key.
              type: string
            name:
              description: A user set name to identify an API key
              type:
                - string
                - 'null'
            obfuscated_secret_key:
              description: >-
                A masked version of the secret key used to authenticate
                requests. This is so that the owner can easily identify which
                key it is without being shown the full secret.
              type: string
            secret_key:
              description: >-
                The secret key used to authenticate requests. This is only
                available if the current actor would have been able to create
                this api key.
              type:
                - string
                - 'null'
          required:
            - id
            - name
            - obfuscated_secret_key
            - secret_key
          type:
            - object
            - 'null'
        description:
          description: >-
            A written description of what this app does, displayed on the app
            store listing page. Null if no description has been set.
          example: >-
            A comprehensive analytics dashboard for tracking revenue, members,
            and growth metrics.
          type:
            - string
            - 'null'
        discover_path:
          description: >-
            The URL path template for a specific view of this app, appended to
            the base domain (e.g., '/experiences/[experienceId]'). Null if the
            specified view type is not configured.
          example: /experiences/[experienceId]
          type:
            - string
            - 'null'
        domain_id:
          description: >-
            The unique subdomain identifier for this app's proxied URL on the
            Whop platform. Forms the URL pattern
            https://{domain_id}.apps.whop.com.
          example: ab1c2d3e4f5g6h7i8j9k
          type: string
        experience_path:
          description: >-
            The URL path template for a specific view of this app, appended to
            the base domain (e.g., '/experiences/[experienceId]'). Null if the
            specified view type is not configured.
          example: /experiences/[experienceId]
          type:
            - string
            - 'null'
        hosted_url:
          description: >-
            The full canonical URL where this app's hosted web build is served.
            Null if the app has not claimed a route.
          example: https://myapp.whop.app
          type:
            - string
            - 'null'
        icon:
          description: >-
            The icon image for this app, displayed on the app store, product
            pages, checkout, and as the default icon for experiences using this
            app.
          properties:
            url:
              description: >-
                A pre-optimized URL for rendering this attachment on the client.
                This should be used for displaying attachments in apps.
              example: https://media.whop.com/abc123/optimized.jpg
              type:
                - string
                - 'null'
          required:
            - url
          type:
            - object
            - 'null'
        id:
          description: The unique identifier for the app.
          example: app_xxxxxxxxxxxxxx
          type: string
        marketplace_status:
          description: >-
            The approval status of this app's product listing on the Whop app
            store. Null if the app has no associated product.
          oneOf:
            - $ref: '#/components/schemas/MarketplaceStatuses'
            - type: 'null'
        name:
          description: >-
            The display name of this app shown on the app store and in
            experience navigation. Maximum 30 characters.
          example: Courses
          type: string
        oauth_client_type:
          $ref: '#/components/schemas/AppOauthClientTypes'
          description: >-
            How this app authenticates when exchanging OAuth authorization and
            refresh grants.
        openapi_path:
          description: >-
            The URL path template for a specific view of this app, appended to
            the base domain (e.g., '/experiences/[experienceId]'). Null if the
            specified view type is not configured.
          example: /experiences/[experienceId]
          type:
            - string
            - 'null'
        origin:
          description: >-
            The full origin URL for this app's proxied domain (e.g.,
            'https://myapp.apps.whop.com'). Null if no proxy domain is
            configured.
          type:
            - string
            - 'null'
        product_id:
          description: >-
            Represents a unique identifier that is Base64 obfuscated. It is
            often used to refetch an object or as key for a cache. The ID type
            appears in a JSON response as a String; however, it is not intended
            to be human-readable. When expected as an input type, any string
            (such as `"VXNlci0xMA=="`) or integer (such as `4`) input value will
            be accepted as an ID.
          type:
            - string
            - 'null'
        production_web_build:
          description: >-
            The approved app build currently served to users on web. Null if no
            production build is deployed for web.
          properties:
            checksum:
              description: >-
                A SHA-256 hash of the uploaded build file, generated by the
                client and used to verify file integrity.
              example: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
              type: string
            file_url:
              description: A URL to download the app build as a .zip archive.
              example: https://cdn.whop.com/builds/abc123.zip
              type: string
            id:
              description: The unique identifier for the app build.
              example: apbu_xxxxxxxxxxxxx
              type: string
            source_url:
              description: >-
                A URL to download the compressed source code archive that
                produced this build. Null if the build was uploaded without a
                source archive.
              example: https://cdn.whop.com/builds/abc123-source.zip
              type:
                - string
                - 'null'
            status:
              $ref: '#/components/schemas/AppBuildStatuses'
              description: The current review status of this build.
          required:
            - id
            - file_url
            - source_url
            - checksum
            - status
          type:
            - object
            - 'null'
        redirect_uris:
          description: >-
            The whitelisted OAuth callback URLs that users are redirected to
            after authorizing the app.
          items:
            description: >-
              Represents textual data as UTF-8 character sequences. This type is
              most often used by GraphQL to represent free-form human-readable
              text.
            type: string
          type: array
        requested_permissions:
          description: >-
            The list of permissions this app requests when installed, including
            both required and optional permissions with justifications.
          items:
            description: >-
              A permission that the app requests from the admin of a company
              during the oauth flow.
            properties:
              is_required:
                description: Whether the action is required for the app to function.
                type: boolean
              justification:
                description: The reason for requesting the action.
                type: string
              permission_action:
                description: >-
                  The action that the app will request off of users when a user
                  installs the app.
                properties:
                  action:
                    description: The identifier of the action.
                    type: string
                  name:
                    description: The human readable name of the action.
                    type: string
                required:
                  - action
                  - name
                type: object
            required:
              - permission_action
              - is_required
              - justification
            type: object
          type: array
        route:
          description: >-
            The unique subdomain route where this app's hosted web builds are
            served, such as 'myapp' for myapp.whop.app. Null if the app has not
            claimed a route.
          example: myapp
          type:
            - string
            - 'null'
        secrets:
          additionalProperties: true
          description: >-
            The app's secrets as an object of string values. Encrypted at rest
            and injected into the app's hosted server runtime as environment
            bindings. Requires the 'developer:update_app' permission.
          type:
            - object
            - 'null'
        skills_path:
          description: >-
            The URL path template for a specific view of this app, appended to
            the base domain (e.g., '/experiences/[experienceId]'). Null if the
            specified view type is not configured.
          example: /experiences/[experienceId]
          type:
            - string
            - 'null'
        stats:
          description: >-
            Aggregate usage statistics for this app, including daily, weekly,
            and monthly active user counts.
          properties:
            dau:
              description: >-
                The number of unique users who have spent time in this app in
                the last 24 hours. Returns 0 if no usage data is available.
              example: 42
              type: integer
            mau:
              description: >-
                The number of unique users who have spent time in this app in
                the last 28 days. Returns 0 if no usage data is available.
              example: 42
              type: integer
            time_spent_last24_hours:
              description: >-
                The total time, in seconds, that all users have spent in this
                app over the last 24 hours. Returns 0 if no usage data is
                available.
              example: 42
              type: integer
            wau:
              description: >-
                The number of unique users who have spent time in this app in
                the last 7 days. Returns 0 if no usage data is available.
              example: 42
              type: integer
          required:
            - dau
            - mau
            - time_spent_last24_hours
            - wau
          type:
            - object
            - 'null'
        status:
          $ref: '#/components/schemas/AppStatuses'
          description: >-
            The current visibility status of this app on the Whop app store.
            'live' means publicly discoverable, 'unlisted' means accessible only
            via direct link, and 'hidden' means not visible anywhere.
        verified:
          description: >-
            Whether this app has been verified by Whop. Verified apps are
            endorsed by Whop and displayed in the featured apps section of the
            app store.
          type: boolean
      required:
        - id
        - name
        - description
        - status
        - base_url
        - domain_id
        - route
        - hosted_url
        - verified
        - app_type
        - origin
        - experience_path
        - discover_path
        - dashboard_path
        - skills_path
        - openapi_path
        - company
        - icon
        - creator
        - requested_permissions
        - stats
        - api_key
        - default_api_key
        - production_web_build
        - redirect_uris
        - secrets
        - product_id
        - marketplace_status
        - oauth_client_type
      type: object
    AppTypes:
      description: The type of end-user an app is built for
      enum:
        - b2b_app
        - b2c_app
        - company_app
        - component
      type: string
    MarketplaceStatuses:
      description: The available marketplace statuses to choose from.
      enum:
        - not_available
        - pending_review
        - live_marketplace
      type: string
    AppOauthClientTypes:
      description: How this app authenticates at the OAuth token endpoint.
      enum:
        - public
        - confidential
      type: string
    AppBuildStatuses:
      description: The different statuses an AppBuild can be in.
      enum:
        - draft
        - pending
        - approved
        - rejected
      type: string
    AppStatuses:
      description: The status of an experience interface
      enum:
        - live
        - unlisted
        - hidden
      type: string
    V1ErrorResponse:
      properties:
        error:
          properties:
            message:
              description: Human-readable error message.
              type: string
            type:
              description: Machine-readable error code.
              type: string
          required:
            - type
            - message
          type: object
      required:
        - error
      type: object
  responses:
    InvalidParameters:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/V1ErrorResponse'
      description: Invalid Parameters
    Unauthorized:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/V1ErrorResponse'
      description: Unauthorized
    Forbidden:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/V1ErrorResponse'
      description: Forbidden
    NotFound:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/V1ErrorResponse'
      description: Resource not found
  securitySchemes:
    bearerAuth:
      bearerFormat: auth-scheme
      description: >-
        A company API key, company scoped JWT, app API key, or user OAuth token.
        You must prepend your key/token with the word 'Bearer', which will look
        like `Bearer ***************************`
      scheme: bearer
      type: http

````