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

# Retrieve Metric

> Retrieves a metric as a time series of points for an account over a time range.



## OpenAPI

````yaml /openapi/api-v1-native.json get /stats/{metric}
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-18'
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: >
      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.
    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 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.'
paths:
  /stats/{metric}:
    parameters:
      - description: >-
          The metric to retrieve, for example net_revenue. Use GET /stats to see
          every metric key. The metric sets the unit and the properties you can
          filter or break down by.
        in: path
        name: metric
        required: true
        schema:
          type: string
      - $ref: '#/components/parameters/ApiVersionDate'
    get:
      tags:
        - Stats
      summary: Retrieve Metric
      description: >-
        Retrieves a metric as a time series of points for an account over a time
        range.
      operationId: retrieveMetric
      parameters:
        - description: The account this query concerns, for example biz_AbC123.
          in: query
          name: account_id
          required: false
          schema:
            type: string
        - description: >-
            Start of the range — a date (YYYY-MM-DD), expanded to the start of
            that day, or an ISO 8601 timestamp (for example
            2026-07-16T16:37:00Z), used exactly.
          in: query
          name: from
          required: true
          schema:
            type: string
        - description: >-
            End of the range — a date (YYYY-MM-DD), expanded to the end of that
            day, or an ISO 8601 timestamp (for example 2026-07-17T16:37:00Z),
            used exactly.
          in: query
          name: to
          required: true
          schema:
            type: string
        - description: >-
            How wide each point is. Defaults to day. Snapshot metrics are
            day-only.
          in: query
          name: interval
          required: false
          schema:
            enum:
              - five_minutes
              - thirty_minutes
              - hour
              - day
              - week
              - month
              - year
            type: string
        - description: >-
            Split the metric out by one of its properties — each point gets a
            breakdown array. For example breakdown_by=currency returns an entry
            for usd, an entry for eur, and so on.
          in: query
          name: breakdown_by
          required: false
          schema:
            type: string
        - description: >-
            Display currency for money metrics — every amount is converted into
            this ISO currency using the exchange rate on each period's date.
            Defaults to usd. For the ads metrics (ad_spend, ad_report), pass the
            account's ads reporting currency to match the ad entity endpoints.
            Ignored when you filter or break down by currency (those report the
            original transaction currency, unconverted).
          in: query
          name: convert_to
          required: false
          schema:
            type: string
        - description: >-
            Filter to transactions made in this original ISO currency, for
            example eur — reported in that currency, not converted. Pair with
            breakdown_by=currency to split a metric by currency. Available on
            metrics that list currency.
          in: query
          name: currency
          required: false
          schema:
            type: string
        - description: >-
            IANA time zone to bucket the series in, for example
            America/New_York. Defaults to UTC. Not accepted by snapshot metrics,
            which are UTC only.
          in: query
          name: time_zone
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single payment method, for example card or crypto.
            Available on metrics that list payment_method.
          in: query
          name: payment_method
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single card brand, for example visa. A refinement of
            payment_method=card. Available on metrics that list card_network.
          in: query
          name: card_network
          required: false
          schema:
            type: string
        - description: >-
            Filter disputes to a normalized reason, for example
            product_not_received. Pair with breakdown_by=dispute_reason to split
            dispute counts by reason.
          in: query
          name: dispute_reason
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single GMV source, for example payments. Pair with
            breakdown_by=source to split by source. Available on metrics that
            list source.
          in: query
          name: source
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single wallet-balance segment, for example available.
            Pair with breakdown_by=segment to split the balance. Available on
            metrics that list segment.
          in: query
          name: segment
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single balance-activity category, for example payments.
            Pair with breakdown_by=category to split the activity. Available on
            metrics that list category.
          in: query
          name: category
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single fee type. Pair with breakdown_by=fee_type to
            split fees by type. Available on metrics that list fee_type.
          in: query
          name: fee_type
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single product (access pass id), for example
            prod_AbC123. Pair with breakdown_by=product. Available on metrics
            that list product.
          in: query
          name: product
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single membership status. Pair with breakdown_by=status.
            Available on metrics that list status.
          in: query
          name: status
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single access level. Pair with
            breakdown_by=access_level. Available on metrics that list
            access_level.
          in: query
          name: access_level
          required: false
          schema:
            type: string
        - description: >-
            Filter to a single most-recent member action. Pair with
            breakdown_by=most_recent_action. Available on metrics that list
            most_recent_action.
          in: query
          name: most_recent_action
          required: false
          schema:
            type: string
        - description: >-
            Filter a referral metric to the businesses attributed to one person
            you referred, for example user_AbC123. Available on metrics that
            list referred_user_id.
          in: query
          name: referred_user_id
          required: false
          schema:
            type: string
        - description: >-
            Ad campaign ids (adcamp_...) to scope the report to; stats are
            summed across them. Available on metrics that list ad_campaign_ids.
          in: query
          name: ad_campaign_ids
          required: false
          schema:
            items:
              type: string
            type: array
        - description: >-
            Ad group ids (adgrp_...) to scope the report to; stats are summed
            across them. Available on metrics that list ad_group_ids.
          in: query
          name: ad_group_ids
          required: false
          schema:
            items:
              type: string
            type: array
        - description: >-
            Ad ids (ad_...) to scope the report to; stats are summed across
            them. Available on metrics that list ad_ids.
          in: query
          name: ad_ids
          required: false
          schema:
            items:
              type: string
            type: array
        - description: >-
            Window used by a snapshot metric. Ordinary snapshots accept 30d as
            their trailing activity window. Cohorted dispute metrics accept 7d
            or 28d as the sales-transaction pool; their attribution window is
            fixed in the metric name. Each metric lists its accepted values in
            the catalog.
          in: query
          name: snapshot_window
          required: false
          schema:
            enum:
              - 7d
              - 28d
              - 30d
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  data:
                    properties:
                      currency:
                        description: >-
                          ISO currency the values are denominated in. Present
                          for currency-unit metrics: the convert_to currency, or
                          usd.
                        nullable: true
                        type: string
                      points:
                        description: One entry per period, oldest first.
                        items:
                          properties:
                            breakdown:
                              description: >-
                                Present only when broken down: one entry per
                                property value in this period.
                              items:
                                properties:
                                  name:
                                    description: >-
                                      The property value, for example usd or
                                      visa.
                                    type: string
                                  value:
                                    description: The metric's value for this entry.
                                    nullable: true
                                    type: number
                                required:
                                  - name
                                  - value
                                type: object
                              type: array
                            timestamp:
                              description: Unix timestamp (seconds) of the period start.
                              type: integer
                            value:
                              description: >-
                                The metric's value for this period, in the
                                metric's unit.
                              nullable: true
                              type: number
                          required:
                            - timestamp
                            - value
                          type: object
                        type: array
                    required:
                      - points
                    type: object
                required:
                  - data
                type: object
          description: a user-scoped metric via a scoped OAuth token
        '400':
          $ref: '#/components/responses/InvalidParameters'
          description: subject tag type mismatch
        '403':
          $ref: '#/components/responses/Forbidden'
          description: a user-scoped metric with a credential that cannot act as a user
        '404':
          $ref: '#/components/responses/NotFound'
          description: unknown account
      security:
        - bearerAuth:
            - stats:read
      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 stat = await client.stats.retrieve('metric', { from: 'from',
            to: 'to' });


            console.log(stat.data);
components:
  parameters:
    ApiVersionDate:
      description: Pins the request to a dated API version.
      in: header
      name: Api-Version-Date
      required: false
      schema:
        example: '2026-07-18'
        type: string
  responses:
    InvalidParameters:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/V1ErrorResponse'
      description: Invalid Parameters
    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

````