> ## 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.

# List App Logs

> Lists a hosted app's server runtime logs, most recent first: console output, uncaught exceptions, and failed-request summaries captured on whop.app hosting. Logs are retained for 7 days.



## OpenAPI

````yaml /openapi/api-v1-native.json get /apps/{id}/logs
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-08-1
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.'
  - name: Stats
    x-whop-summary: Aggregated financial time series for 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 balance to an external
      destination, such as a bank account or other supported payout method.


      Use the Payouts API to list payout history, monitor payout statuses, and
      show expected arrival details for funds leaving an account.
    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 and
      retrieve existing bank deposit activity.
    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 an identity review 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: Identity review 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: >
      Referrals track businesses referred to Whop and the earnings generated
      from their processing volume. They help you see how much volume your
      referred businesses have processed and how much you've earned from them.


      Use the Referrals API to list referred businesses, retrieve one referral,
      and review earnings across all referrals or for a single referred
      business.
    name: Referrals
    x-whop-summary: Track who referred a purchase and what they earn.
  - 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 and list 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.
    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.
    name: Social Accounts
    x-whop-summary: Connected Facebook and Instagram accounts that run ads.
  - description: >
      An App is software you build on the Whop platform — from a fully-hosted
      web app served at `<route>.whop.app` to an API integration installed into
      whops as experiences. Apps belong to an account and hold their own
      credentials and settings.


      Use the Apps API to create and configure apps, and — for hosted apps —
      read their server runtime logs: every console line, uncaught exception,
      and failed request is captured for 7 days and queryable by build, level,
      time window, and message text.
    name: Apps
    x-whop-summary: 'Apps you build on Whop: metadata, hosted builds, runtime logs.'
paths:
  /apps/{id}/logs:
    get:
      tags:
        - Apps
      summary: List App Logs
      description: >-
        Lists a hosted app's server runtime logs, most recent first: console
        output, uncaught exceptions, and failed-request summaries captured on
        whop.app hosting. Logs are retained for 7 days.
      operationId: listAppLogs
      parameters:
        - description: The ID of the app, which will look like app_*************.
          in: path
          name: id
          required: true
          schema:
            type: string
        - description: Only return logs from this build.
          in: query
          name: app_build_id
          required: false
          schema:
            type: string
        - description: Only return console lines of this level.
          in: query
          name: level
          required: false
          schema:
            enum:
              - log
              - debug
              - info
              - warn
              - error
            type: string
        - description: >-
            Only return logs whose message contains this text
            (case-insensitive).
          in: query
          name: query
          required: false
          schema:
            type: string
        - description: >-
            Start of the time window as an ISO 8601 timestamp. Defaults to 7
            days before created_before.
          in: query
          name: created_after
          required: false
          schema:
            format: date-time
            type: string
        - description: End of the time window as an ISO 8601 timestamp. Defaults to now.
          in: query
          name: created_before
          required: false
          schema:
            format: date-time
            type: string
        - description: The number of log lines to return (max 500).
          in: query
          name: first
          required: false
          schema:
            type: integer
        - description: A cursor for fetching logs after a previous page.
          in: query
          name: after
          required: false
          schema:
            type: string
        - description: A cursor for fetching logs before a later page.
          in: query
          name: before
          required: false
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  data:
                    items:
                      properties:
                        app_build_id:
                          type: string
                        app_id:
                          type: string
                        cpu_time_ms:
                          type: integer
                        created_at:
                          format: date-time
                          type: string
                        level:
                          type: string
                        message:
                          type: string
                        outcome:
                          type:
                            - string
                            - 'null'
                        request_id:
                          type: string
                        request_method:
                          type:
                            - string
                            - 'null'
                        request_path:
                          type:
                            - string
                            - 'null'
                        response_status:
                          type:
                            - integer
                            - 'null'
                        source:
                          enum:
                            - console
                            - exception
                            - request
                          type: string
                        stack:
                          type:
                            - string
                            - 'null'
                        truncated:
                          type: boolean
                        wall_time_ms:
                          type: integer
                      required:
                        - app_id
                        - app_build_id
                        - request_id
                        - created_at
                        - source
                        - level
                        - message
                      type: object
                    type: array
                  page_info:
                    properties:
                      end_cursor:
                        type:
                          - string
                          - 'null'
                      has_next_page:
                        type: boolean
                      has_previous_page:
                        type: boolean
                      start_cursor:
                        type:
                          - string
                          - 'null'
                    required:
                      - has_next_page
                      - has_previous_page
                    type: object
                required:
                  - data
                  - page_info
                type: object
          description: logs listed
        '401':
          $ref: '#/components/responses/Unauthorized'
          description: missing or invalid authentication
        '403':
          $ref: '#/components/responses/Forbidden'
          description: missing the developer:logs:read scope
        '404':
          $ref: '#/components/responses/NotFound'
          description: app not found
      security:
        - bearerAuth:
            - developer:logs:read
components:
  responses:
    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
  schemas:
    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
  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

````