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

# Update Payment

> Updates a payment's `shipping_address` or `return_url`. Send the complete `shipping_address`, because it replaces the existing address and any field you leave out is cleared.



## OpenAPI

````yaml /openapi/api-v1-native.json patch /payments/{id}
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-09-28'
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, suspend or delete a connected
      account managed by your platform, 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.
  - description: >
      A Member is one buyer's relationship with an account — one record per
      customer regardless of how many memberships they hold. It carries
      relationship-level state: whether they have joined or left, their access
      level (`customer`, `admin`, or `no_access`), when they joined, and when
      they last opened the account's content.


      Use the Members API to list an account's members with filtering by access
      level, status, join date, and name or username search, and to retrieve a
      single member. Member rows are created and maintained by the membership
      lifecycle; to grant or revoke access, work with memberships instead.
    name: Members
    x-whop-summary: One buyer's relationship with an account, across all their purchases.
  - description: >
      Economic Intelligence is Whop's recommendation engine for an account. Each
      recommendation is a single action: a title the owner sees, a step-by-step
      brief Whop AI carries out, and the bet it makes on the account's ledger.
      Whop generates them from the account's sales, site, ads, and what its
      owner has said.


      Use the Economic Intelligence API to list recommendations and to request
      actions for a specific goal with POST. For callers with company:update
      permission, listing automatically queues generation when no actions are
      ready or in progress, with a ten-minute cooldown after an unsuccessful
      request from the current pipeline version. A new request returns a
      recommendation with status `queued`; the engine moves it through `pending`
      to `ready`. Unsuccessful requests are omitted from the list. A `ready`
      recommendation becomes `executed` once the owner runs it from the
      dashboard, or `superseded` when a newer one replaces it.
    name: Economic Intelligence
    x-whop-summary: What an account should do next to grow, generated from its own data.
  - 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 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: >
      An Export is an asynchronous CSV of one resource for one account —
      members, payments, disputes, ads, and the other tables the Whop dashboard
      can export. Generating a full table takes longer than a request, so an
      export is created in `pending`, moves through `processing`, and lands on
      `completed` with a download link. Each resource requires that resource's
      own export scope.


      Use the Exports API to start an export, poll it until `download_url` is
      set, and list the exports already requested for an account. Finished CSVs
      are retained for 30 days, after which the file is deleted and the export
      moves to `expired`.
    name: Exports
    x-whop-summary: Asynchronous CSV dumps of an account's dashboard data.
  - description: >
      A Notification is a message delivered to a user — a new post, a payment, a
      mention. Every notification comes from an experience the user belongs to
      or a team they are on, and users control what they receive with
      notification preferences.


      Every notification belongs to a topic: the category it falls under, such
      as new sales or account activity. Topics carry a default, so a user only
      needs a preference row where they diverge from it. `GET
      /notifications/topics` lists the platform's visible topics, and a topic's
      `id` is what the notification preference endpoints take as `topic_id` —
      the catalog is the only place those ids come from, so read it rather than
      hardcoding. Each topic also carries an `identifier` such as
      `new-follower`, which is stable across environments and is the value to
      match on in code.


      Use the Notifications API to list the authenticated user's feed, read
      per-experience unread badges, mark an experience (or everything) as read,
      send notifications from your app to an experience's users or an account's
      team, and list the topic catalog.
    name: Notifications
    x-whop-summary: >-
      The user's notification feed: unread badges, mark-read, app sends, and the
      topic catalog.
  - description: >
      A Payment is one charge against a buyer. Create an on-session payment with
      a `confirmation_token` for the method the buyer selected, or an
      off-session payment with an existing member's stored payment method.


      Collection runs in the background, so the create response is not the
      outcome. Poll [Retrieve
      status](/api-reference/beta/payments/retrieve-payment-status) for how far
      the payment has gone and, while it is `requires_action`, what the buyer
      must do next — follow a redirect, complete 3D Secure, display transfer
      instructions, or link a bank account. Use the return_url operation to
      change where they land afterwards, up until they come back.
    name: Payments
    x-whop-summary: A charge against a buyer, and the step they still owe.
  - description: >
      A Refund is one reversal of a payment, full or partial. Refunds are issued
      with `POST /payments/{id}/refund`; this resource is the record of each one
      — how much moved, through which provider, and where it stands (`pending`,
      `succeeded`, `failed`).


      List a payment's refunds with `?payment_id=`, or every refund an account
      issued with `?account_id=`. `amount` is stated in the payment's settlement
      currency so it nets against the payment's `total`; `original_amount` is
      what the processor moved.
    name: Refunds
    x-whop-summary: Money returned to a buyer from a payment.
  - description: >
      A Confirmation Token is a single-use, short-lived reference to a payment
      method and billing details collected from a buyer. Its response never
      returns the underlying payment credential. Public callers receive a
      billing preview; bearer-authenticated callers with `payment:basic:read` on
      the token’s account also receive the collected billing address.


      Whop Elements mint the token in your buyer-facing collection flow and hand
      you its `ctok_` ID to send to the Payments API from your server. Retrieve
      a token to display its payment method and billing preview or check whether
      it is still usable.
    name: Confirmation Tokens
    x-whop-summary: A short-lived reference to payment details collected from a buyer.
  - description: >
      A Setup Intent saves a buyer's payment method for later without taking
      money now. Create one from a confirmation token the payment elements
      collected in setup mode, or from a payment method already on file to
      re-verify it. It runs the same collection flow a payment does, so the
      buyer may still owe a step: 3D Secure on a card, a hosted enrollment, or
      linking a bank account.


      The create response is the setup intent as created, not its outcome. Hand
      its `client_secret` to the elements' `handleNextAction`, or poll [Retrieve
      status](/api-reference/beta/setup-intents/retrieve-setup-status) for how
      far the setup has gone and what is outstanding. Once it reaches
      `succeeded`, `payment_method_id` names the saved method and Create Payment
      charges it.
    name: Setup Intents
    x-whop-summary: Saving a buyer's payment method without charging it.
  - description: >
      A Payment Rule lets an account act on its own payments before they reach
      the bank: block them, let them through, send them to review, or ask the
      buyer for 3D Secure. Each rule matches on a small set of payment
      attributes, and every condition must hold for it to apply.


      A rule's definition is fixed once created, so the payments it decided keep
      naming the rule that decided them. Use
      [Replace](/api-reference/beta/payment-rules/replace-a-payment-rule) to
      change one, and [List
      fields](/api-reference/beta/payment-rules/list-fields) for the attributes,
      operators and values a condition can use.
    name: Payment Rules
    x-whop-summary: Rules an account writes to decide its own payments.
  - description: >
      A Dispute is a chargeback a customer files against a payment through their
      bank, or an inquiry that may become one. It carries the disputed payment,
      a deadline to respond, your evidence, and the outcome once the processor
      rules.


      Use the Disputes API to list disputes, edit the evidence packet while a
      dispute is still contestable, and submit it for review.
    name: Disputes
    x-whop-summary: Chargebacks filed against an account, with evidence and outcomes.
  - description: >
      A Dispute alert is an early warning from a card issuer that a settled
      payment is being questioned, ahead of any chargeback. `type` separates
      fraud reports (`early_fraud_warning`), pre-dispute notices
      (`dispute_alert`), and Visa RDR cases the network already closed by
      refunding (`rapid_dispute_resolution`).


      Use the Dispute alerts API to list alerts for an account, filter them by
      type or payment, and read `actionable` to see whether refunding can still
      avoid the chargeback.
    name: Dispute alerts
    x-whop-summary: Issuer warnings that arrive before a chargeback does.
  - description: >
      A Resolution Center Case is opened by a buyer when something is wrong with
      a purchase — an unwanted renewal, an item that never arrived, or a charge
      they don't recognize. It is the step before a chargeback: the two sides
      work it out directly, and Whop decides the case if they can't. Each case
      carries a reason, a status naming which side it is waiting on, a timeline
      of events, and the actions available to whoever is reading it.


      Use the Resolution Center Cases API from either side: as the buyer, open a
      case, reply, appeal a decision, or withdraw it; as the merchant, accept it
      (refunding the payment), deny it, or ask the buyer for more information.
      Both sides read the same case, page its timeline, and summarize the cases
      they can see.
    name: Resolution Center Cases
    x-whop-summary: File or respond to a case against a payment, as the buyer or the merchant.
  - description: >
      A Ledger Activity row is a single financial event on an account's ledger —
      a payment, payout, 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 group credits and debits by when they affect available
      funds. Pending activity uses its scheduled release date; activity posted
      to available funds uses its posted time, including refunds, disputes and
      payouts. Default activity excludes some movements, including opt-in
      reserves.
    name: Ledgers
    x-whop-docs-title: Financial Activity
    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 and track payouts, manage saved payout
      methods, 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: >
      Cashback rules designate a funding platform, optional merchant name and
      category filters, a rate, and an eligibility window. Every supplied
      merchant filter must match. An account ID limits the rule to one of the
      platform's direct connected accounts and is required when both merchant
      filters are omitted or null.


      Use the Cashback Rules API to create future-dated rules, update their
      merchant name, MCC, description, or expiration, and list every rule funded
      by the authenticated platform, including expired and discarded rules.
      Discarded rules cannot be updated. Creating or updating a rule does not
      transfer funds.


      Pay out cashback on demand from the platform's available USD balance with
      optional rule, account, and transaction filters. Only completed, unpaid,
      eligible transactions are paid. The response returns status `processing`
      and echoes supplied filters; `failed` means the queue rejected the
      request. These statuses describe scheduling, not payment completion.
    name: Cashback Rules
    x-whop-summary: Configure platform-sponsored card cashback.
  - 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.


      Subscribe to `transfer.completed` and `transfer.failed` for outcomes
      instead of polling. Each participating account can subscribe to these
      events. `transfer.created` is also emitted on success, not when processing
      starts. A failed transfer can be retried under the same ID and later
      succeed; retrieve the transfer to reconcile its current status.


      A successful balance transfer credits the recipient's available balance
      unless a release date applies. Transfers funded from pending balance
      retain a release date and credit pending balance; applicable recipient
      reserves or fraud holds can keep funds unavailable. `succeeded` confirms
      the transfer completed, not that all funds are withdrawable.
    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. Crypto
      deposits require a $10 minimum.
    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 Trade records an order batch, cancellation, or leverage change submitted
      to a trading provider from an account or user's Whop-managed wallet. Its
      `status` tracks the submission, not whether orders filled.


      Use the Trades API to place limit or market orders with optional
      take-profit and stop-loss protection, cancel a submitted batch, set
      leverage, and list or retrieve past submissions. Read live margin,
      positions, and open orders by passing `include_trading=true` to Retrieve
      Account or Retrieve User with `id=me`. Whop's builder fee is added to each
      order. Hyperliquid perpetuals are currently supported; email
      support@whop.com to request access.
    name: Trades
    x-whop-summary: Submit and track perpetual trades.
  - description: >
      A Product is a digital good or service sold on Whop. Products contain
      variants for pricing and may contain experiences for content delivery.


      Use the Products API to search the public marketplace, list an account's
      products, retrieve a product, and create, update, or delete products.
    name: Products
    x-whop-summary: The things you sell. Each owns variants and a store page.
  - description: >
      Join a free variant's waitlist, read or cancel your own signups, and
      manage signups for accounts you are authorized to operate.

      Joining does not grant membership or charge a payment method. Seller
      approval runs asynchronously and can charge a saved payment method for a
      paid variant.
    name: Waitlist Entries
    x-whop-summary: Join waitlists and manage customer signups awaiting approval.
  - description: >
      A Variant is one purchasable configuration of a product. It controls
      price, billing cadence, stock, SKU, attributes, tax behavior, checkout
      fields, and purchase visibility. Variant IDs remain prefixed `plan_`.


      Use the Variants API to create variants for products, list existing
      variants, retrieve or update variant configuration, calculate tax for
      checkout, and delete variants that should no longer be offered.
    name: Variants
    x-whop-summary: Purchasable configurations of a product.
  - description: >
      Plans is the former public name for Variants. Existing integrations can
      keep calling these deprecated endpoints while they migrate; every response
      points to the matching Variants endpoint.


      Use the Variants API for all new integrations. Variant IDs retain their
      existing `plan_` prefix, and the underlying resource is unchanged.
    name: Plans
    x-whop-summary: Deprecated compatibility endpoints for variants.
  - name: Promo Codes
    x-whop-summary: Discounts that creators configure for checkout.
  - description: >
      A Membership is a customer's purchase of a variant: the subscription or
      one-time grant that gives them access to a product. It tracks billing
      state (`active`, `trialing`, `past_due`, and so on), the current period,
      pending cancellations, custom metadata, and the software license key when
      the product includes licensing.


      Use the Memberships API to list an account's memberships or the caller's
      own, retrieve one by ID or license key, invite a recipient to join through
      a free variant, and manage the lifecycle: cancel immediately or at period
      end, reverse a scheduled period-end cancellation, pause and resume payment
      collection, extend with free days, generate a transfer link, and update
      metadata.
    name: Memberships
    x-whop-summary: A customer's purchase of a variant, from checkout through cancellation.
  - description: >
      A Checkout Configuration is a reusable checkout link owned by an account.
      In `payment` mode it sells a specific variant; 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 variant, 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 variant into a shareable, prefilled checkout link.
  - description: >
      A Payment Method Domain registers a hostname with a wallet provider so its
      payment methods can appear at a checkout served from that domain. The
      domain proves ownership by hosting the provider's association file — for
      Apple Pay, at `/.well-known/apple-developer-merchantid-domain-association`
      — and `status` reports whether verification has completed.


      Use the Payment Method Domains API to register domains for your account or
      its connected accounts, retry verification once the association file is
      hosted, and remove domains that should no longer serve wallet payments. A
      domain a platform shares with its connected accounts at checkout is listed
      on the platform's account, not on each connected account.


      Wallet buttons at checkout depend on this: embedded surfaces like the
      [Express Checkout element](/elements/beta/checkout/expressCheckout) only
      render Apple Pay on a `verified` domain (first-party whop.com pages are
      pre-approved). To verify a domain, [create
      it](/api-reference/beta/payment-method-domains/create-payment-method-domain),
      host the association file at the path above, then [retry
      verification](/api-reference/beta/payment-method-domains/verify-payment-method-domain)
      until `status` is `verified`.
    name: Payment Method Domains
    x-whop-summary: >-
      Domains verified to show wallet payment methods like Apple Pay at
      checkout.
  - description: >
      A Shipment attaches a carrier tracking number to a payment and follows the
      package from label creation to delivery, exposing the current delivery
      status and a customer-facing tracking URL.


      Use the Shipments API to list an account's shipments, retrieve one by its
      id or the payment it fulfills, attach a tracking number to a payment, and
      update the tracking number on an existing shipment.
    name: Shipments
    x-whop-summary: Track the delivery of an order by its carrier tracking number.
  - description: >
      Partner Referral Requests let partners create referral links and request
      attribution for an existing business or enrolled partner, with manual
      requests requiring recipient approval.
    name: Partner Referral Requests
    x-whop-summary: Request business or partner attribution and manage approval.
  - description: >
      Get started at [whop.com/network](https://whop.com/network). A Partner is
      a user who refers people and businesses to Whop. The partner profile
      includes enrollment, active direct business referral counts, and default
      payout terms.


      Retrieve your profile with `/partners/{id}`. Use
      `/partner_referral_requests` to create and manage referral links and their
      rewards. You can also enroll in the partner program, review referred users
      and businesses, track earnings, and see the partner leaderboard.
    name: Partners
    x-whop-summary: >-
      Your partner profile, referral links, payout rates, and referred
      businesses.
  - 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 is an identity-linked profile of a visitor or customer of an
      account, assembled from every [event](/api-reference/beta/events/event)
      the person generated — pixel page views, ad clicks, leads, identifies, and
      payments. Each profile carries the person's known identities (names,
      emails, phones, user IDs), purchase history and LTV, geo/device profile,
      traffic sources, and the first and last marketing touches that reached
      them.


      Use the People API to list and segment the people of an account — filter
      by activity, purchases, traffic source, location, or marketing touch, and
      sort by value — or retrieve one person by person ID, user ID, email
      address, or phone number.
    name: People
    x-whop-summary: >-
      Visitors and customers of an account, with identity, purchase, and traffic
      profiles.
  - 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. The resource also exposes an anonymized read mode — the pulse
      feed — a platform-wide snapshot of recent purchases that carries nothing
      identifying. The pulse feed is public; other Events endpoints require
      authentication and are scoped to an account.


      Events are only as good as the pixel sending them, so [Validate
      Pixel](/api-reference/beta/events/validate-pixel) answers whether an
      account's pixel is working: it reads the events the pixel has sent, and
      when you pass a `url` whose page hasn't sent any lately, it fetches that
      page and looks for the pixel in its source. Use it before launching an ad
      to confirm its destination is tracked, or in a setup flow to tell a
      merchant whether their install is live.
    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: >
      A conversion value rule allows you to report accurate conversion values to
      Whop while modifying how those values are sent to ad networks. Rules
      belong to an account and can apply to an account, an ad campaign, an ad
      group, or an ad.


      Each rule contains targets and events that share one value adjustment.
      Every selected event applies to every selected target. Create, retrieve,
      edit, delete, pause, or resume one rule by its ID. Create may set an
      initial active or paused status. Edits keep that status. Filter the list
      with resource_id to find rules overlapping a campaign, ad group, or ad.
      Every target must support every selected event; Google does not support
      named custom events. Create and edit accept replace_rule_ids to replace
      only the overlapping selections in the same transaction. Other selections
      keep their values. Remaining selections may split into separate rules so
      every event still applies to every target. Broader rules remain as
      fallbacks for other items; the most specific rule applies. Rules with no
      remaining selections are paused. Unpause automatically replaces
      overlapping selections using the same behavior as create and edit: other
      selections keep their values, and broader rules remain as defaults.
      Resuming an already-active rule makes no changes. Each write succeeds or
      fails as one transaction. Use Idempotency-Key to safely retry POST
      requests. Each conversion send attempt uses the rules saved at that time,
      including retries.
    name: Ad Conversion Value Rules
    x-whop-summary: Modify how conversion events are delivered to ad networks.
  - 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.


      Ads billing combines eligible spend across the account's campaigns. A
      failed payment blocks delivery with `delivery_status: payment_failed`
      while preserving the configured active/paused `status`. Fix the account's
      payment method and [retry its ads
      payment](/api-reference/beta/accounts/retry-failed-ads-payments) once for
      the account. The retry is asynchronous: acceptance does not confirm
      payment. Successful settlement clears the block; active campaigns can
      resume if otherwise eligible, while paused campaigns stay paused. See
      [billing and retries](/developer/ads/overview#paying-for-ads).
    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 is a reusable group of people to include or exclude when
      targeting ads. Build custom audiences from customer lists, Whop People
      data, or social engagement, and create lookalikes to reach people similar
      to an existing audience.


      Use the Audiences API to create, list, and delete audiences and monitor
      asynchronous processing. Meta engagement sources include videos, lead
      forms, Instagram profiles, and Facebook pages. Engagement membership
      updates on Meta; Whop People audiences can refresh automatically or keep a
      snapshot.
    name: Audiences
    x-whop-summary: Reusable targeting lists for ad groups.
  - description: >
      A File is an uploaded document or media object, identified by a `file_`
      ID. Creating a file returns a presigned destination; upload the bytes
      there and the file becomes `ready`.


      Use the Files API to create a file, upload its content directly to storage
      (in one PUT, or in parts for large files), and retrieve it while polling
      for readiness. A ready file's ID can be attached wherever Whop accepts
      files.
    name: Files
    x-whop-summary: Upload files and attach them wherever Whop accepts documents.
  - 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.site` 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, deploy an app's working copy
      and follow the run on the app's `deployment` field, 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.


      Apps are also reusable blueprints. List official blueprints with
      `app_type=website&verified=true&order=template_usage`, or community
      blueprints with
      `app_type=website&verified=false&recommended=true&order=template_usage`.
      Pass the returned App `id` as `blueprint_id` when creating an Account.
    name: Apps
    x-whop-summary: 'Apps you build on Whop: metadata, hosted builds, runtime logs.'
  - description: >
      A Domain is an account's claim to a hostname and its app assignment.
      Publish the returned ownership TXT and routing DNS records. Verification
      and certificate provisioning run automatically; unverified claims expire
      after 48 hours. Only verified domains with active hostname and certificate
      status resolve through the Apps API.


      An unverified claim does not reserve a hostname globally. Transferring
      ownership requires a fresh TXT proof and an explicit replacement request.
      Removing a domain stops app resolution immediately while Cloudflare
      cleanup finishes in the background.
    name: Domains
    x-whop-summary: Custom domains assigned to hosted apps.
  - 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 an account 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.
  - description: >
      An Api Log is a record of a single request made to Whop's API using one of
      your account's API keys — the programmatic counterpart to the dashboard
      audit log, which only records actions taken by signed-in team members.
      Reads and failed requests are logged too.


      Use the Api Logs API to see what your integrations are doing on Whop: the
      operation, HTTP method and status, outcome, and timing of each request,
      newest first.
    name: Api Logs
    x-whop-summary: Requests made to Whop's API with your account's API keys.
  - description: >
      A Permission is one action, such as `stats:read`, paired with whether your
      credential is granted it on a given resource. It answers for whatever you
      authenticated with, so you can decide what to show or attempt instead of
      discovering a `403`.


      Use the Permissions API to check an account, product, experience, or app,
      narrowing to the actions you care about. It reports only your own access —
      to manage who else can reach an account, use the Team Members API.
    name: Permissions
    x-whop-summary: What your credential is allowed to do on a resource.
  - description: >
      Experiments belong to an account. Use `account_id` to select the owning
      account, or `internal` for Whop's platform experiments. Reading and
      managing account experiments requires `experiment:read` or
      `experiment:manage`; internal configuration requires Whop internal access.
      Exposure is callable without authentication.


      Create a draft, configure treatment weights and targeting, then activate,
      pause, or end it. Treatments occupy stable percentage ranges; the
      remainder is control. Growing an allocation preserves existing treatment
      assignments. Optional `related_resource` references attach experiments,
      control, and variants to resources owned by the account. Bindings cannot
      change after first activation.


      `GET /experiments/exposures` evaluates and records exposure. Ownership is
      separate from `subject` identity: `subject[user_id]`,
      `subject[account_id]`, and `subject[anonymous_id]` supply the experiment's
      bucketing unit. Internal user identity comes from the authenticated
      session. Resolved authentication is recorded on the event separately from
      the subject. Pass a flag key and its account, or a globally unique
      experiment ID. Without a flag key, evaluation returns active experiments
      in the account and related resource scope.


      Account experiments run without a reporting provider. Statistical results
      and the metric catalog currently remain internal. Configuration responses
      include an assignment seed and revision for consumers that cache
      experiment definitions.
    name: Experiments
    x-whop-summary: >-
      Feature flags and A/B experiments for gradual rollout and statistical
      measurement.
paths:
  /payments/{id}:
    parameters:
      - $ref: '#/components/parameters/ApiVersionDate'
      - description: The payment, prefixed `pay_`.
        in: path
        name: id
        required: true
        schema:
          type: string
    patch:
      tags:
        - Payments
      summary: Update Payment
      description: >-
        Updates a payment's `shipping_address` or `return_url`. Send the
        complete `shipping_address`, because it replaces the existing address
        and any field you leave out is cleared.
      operationId: updatePayment
      parameters: []
      requestBody:
        content:
          application/json:
            schema:
              properties:
                return_url:
                  description: >-
                    Where the buyer continues after completing an off-site step.
                    An absolute https URL without credentials, at most 2,048
                    characters. Only for payments created with a
                    `confirmation_token`, and only until the buyer has returned.
                    Omit it to leave it unchanged.
                  example: https://shinetime.example/checkout/thanks
                  type: string
                shipping_address:
                  description: >-
                    The complete new shipping address. It replaces the current
                    address as a whole and is never merged with it, so send
                    every field the address should have, including the ones that
                    are not changing. Any field you leave out is cleared:
                    sending only `city` leaves an address with nothing but a
                    city. Pass null to remove the address, or omit
                    `shipping_address` to leave it unchanged. It cannot change
                    once a shipment exists for the payment.
                  properties:
                    city:
                      description: City name.
                      example: Austin
                      type:
                        - string
                        - 'null'
                    country:
                      description: ISO 3166-1 alpha-2 country code, such as `US`.
                      example: US
                      type:
                        - string
                        - 'null'
                    line1:
                      description: First line of the street address.
                      example: 1114 Bouldin Ave
                      type:
                        - string
                        - 'null'
                    line2:
                      description: Second line of the street address.
                      example: Unit B
                      type:
                        - string
                        - 'null'
                    name:
                      description: >-
                        The recipient's full name, as it should appear on the
                        shipping label.
                      example: Dana Whitfield
                      type:
                        - string
                        - 'null'
                    postal_code:
                      description: Postal or ZIP code.
                      example: '78704'
                      type:
                        - string
                        - 'null'
                    state:
                      description: State, province, or region code, such as `CA`.
                      example: TX
                      type:
                        - string
                        - 'null'
                  type:
                    - object
                    - 'null'
              required: []
              type: object
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Payment'
          description: shipping address replaced
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/V1ErrorResponse'
          description: shipping_address is not an object
        '401':
          $ref: '#/components/responses/Unauthorized'
          description: unauthenticated
        '403':
          $ref: '#/components/responses/Forbidden'
          description: credential without payment:manage
        '404':
          $ref: '#/components/responses/NotFound'
          description: payment not found
      security:
        - bearerAuth:
            - payment:manage
components:
  parameters:
    ApiVersionDate:
      description: Pins the request to a dated API version.
      in: header
      name: Api-Version-Date
      required: false
      schema:
        example: '2026-09-28'
        type: string
  schemas:
    Payment:
      properties:
        account_id:
          description: The account that received the payment, prefixed `biz_`.
          example: biz_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        amount_after_fees:
          $ref: '#/components/schemas/Money'
          description: 'What the account keeps: the total less Whop''s fees.'
        auto_refunded:
          description: >-
            True when Whop refunded the payment automatically, for example on a
            dispute alert.
          example: false
          type: boolean
        billing_address:
          description: The billing address the buyer entered, or null.
          oneOf:
            - $ref: '#/components/schemas/PaymentAddress'
            - type: 'null'
        billing_reason:
          description: >-
            Why the charge was created: a first purchase, a renewal, a one-time
            payment, or a manual charge.
          oneOf:
            - $ref: '#/components/schemas/BillingReasons'
            - type: 'null'
        checkout_configuration_id:
          description: >-
            The checkout configuration the buyer paid through, prefixed `ch_`,
            or null.
          example: null
          type:
            - string
            - 'null'
        client_secret:
          description: >-
            The credential a buyer's surface presents to poll this payment and
            set its return URL. Only on payments created from a confirmation
            token, and always null in list responses — retrieve the payment for
            it.
          example: >-
            pay_xxxxxxxxxxxxxx_secret_vdefault_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        created_at:
          description: When the payment was created, as an ISO 8601 timestamp.
          example: '2026-01-01T12:00:00.000Z'
          type: string
        currency:
          $ref: '#/components/schemas/Currencies'
          description: >-
            The currency the payment settles in, lowercase ISO 4217. Every money
            field below is stated in it unless it says otherwise.
        customer_email:
          description: >-
            The buyer's email address. Null without `member:email:read` on the
            account or when the buyer has no assigned email.
          example: marcus@shinetime.example
          type:
            - string
            - 'null'
        customer_phone:
          description: The phone number the buyer gave at checkout, when one was collected.
          example: +xxxxxxxxxxx
          type:
            - string
            - 'null'
        decline_code:
          description: >-
            The normalized decline reason of the most recent failed attempt, or
            null.
          oneOf:
            - $ref: '#/components/schemas/PaymentDeclineCodes'
            - type: 'null'
        dispute_alerted_at:
          description: When an issuer warned that this payment will be disputed, or null.
          example: null
          type:
            - string
            - 'null'
        failure_message:
          description: Why the most recent attempt failed, in plain words, or null.
          example: null
          type:
            - string
            - 'null'
        financing_installments_count:
          description: For installment methods, how many payments the charge splits into.
          example: null
          type:
            - number
            - 'null'
        holds:
          items:
            $ref: '#/components/schemas/PaymentHold'
            description: >-
              The active holds on this payment. Each hold has its own release
              date, independent of `settlement_time_at`. Empty when nothing is
              held; released holds are omitted.
          type: array
        id:
          description: Payment ID, prefixed `pay_`.
          example: pay_xxxxxxxxxxxxxx
          type: string
        last_payment_attempt_at:
          description: When the most recent charge attempt ran, or null.
          example: null
          type:
            - string
            - 'null'
        line_items:
          items:
            $ref: '#/components/schemas/ReceiptLineItem'
            description: >-
              Everything this payment charged for, in purchase order, with
              quantities and subtotals in the purchase currency. Payments made
              before item snapshots were recorded return the single item implied
              by their variant. Empty when no items or variant can be resolved.
          type: array
        member_id:
          description: >-
            The buyer's member record on the account, prefixed `mber_`. Null
            without the member:basic:read permission.
          example: mber_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        membership_id:
          description: >-
            The membership this payment is billed against, prefixed `mem_`. Null
            for one-off purchases or without the member:basic:read permission.
          example: mem_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        metadata:
          description: Your own key-value data attached when the payment was created.
          example:
            order_ref: SHINE-4417
          type:
            - object
            - 'null'
        needs_tracking:
          description: >-
            True when funds are held until the order ships and no tracking
            number has been added yet. Null without the shipment:basic:read
            permission.
          example: false
          type:
            - boolean
            - 'null'
        next_payment_attempt_at:
          description: When the next automatic retry is scheduled, or null.
          example: null
          type:
            - string
            - 'null'
        paid_at:
          description: When the money was collected, or null while it has not been.
          example: '2026-01-01T12:00:00.000Z'
          type:
            - string
            - 'null'
        payment_instrument:
          description: >-
            The instrument shaped for display: a buyer-facing name, the standard
            icon set, and the card's brand, last four and issuer identification
            number when it was a card.
          oneOf:
            - $ref: '#/components/schemas/PaymentInstrument'
            - type: 'null'
        payment_method_id:
          description: >-
            The stored payment method that was charged, prefixed `payt_`. Null
            when the method was not saved.
          example: payt_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        payment_method_type:
          description: >-
            The kind of instrument used, for example `card`, `apple_pay`,
            `klarna`, or `us_bank_account`.
          oneOf:
            - $ref: '#/components/schemas/PaymentMethodTypes'
            - type: 'null'
        payment_rule_matches:
          items:
            $ref: '#/components/schemas/PaymentRuleMatch'
            description: >-
              The account's own payment rules that decided this payment,
              recorded when they ran. Only one action is taken per payment, so a
              rule that matched but was skipped or outranked is not listed.
              Empty when none decided it, when the account had no rules, or when
              Whop blocked the payment before they ran.
          type: array
        payments_failed:
          description: How many charge attempts have failed on this payment.
          example: 0
          type: number
        plan_id:
          description: The variant that was charged, prefixed `plan_`.
          example: plan_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        presentment_total:
          description: >-
            The account-facing total in the currency presented to the buyer,
            before conversion into the settlement currency. Excludes buyer fees.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        product_id:
          description: >-
            The product the variant belongs to, prefixed `prod_`. Null for a
            variant with no product.
          example: prod_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        promo_code_id:
          description: The promo code applied at checkout, prefixed `promo_`, or null.
          example: null
          type:
            - string
            - 'null'
        recovery_url:
          description: >-
            Whop-hosted URL where the buyer can sign in and complete 3D Secure
            for an off-session charge the bank challenged — a subscription
            renewal or a saved-card payment. Null when recovery is unavailable,
            you lack `member:basic:read`, or in list responses. Retrieve the
            payment for it.
          example: null
          type:
            - string
            - 'null'
        refundable:
          description: >-
            True when the payment is `paid`, not yet fully refunded, and its
            processor supports refunds.
          example: false
          type: boolean
        refunded_amount:
          description: >-
            How much has been refunded so far, as it settled — refunds convert
            at the rate in force when each one was issued, not the payment's
            original rate.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        refunded_at:
          description: When the payment was refunded, or null.
          example: null
          type:
            - string
            - 'null'
        retryable:
          description: >-
            True when the payment is `open` and Whop can attempt the charge
            again — see `POST /payments/{id}/retry`.
          example: true
          type: boolean
        risk_score:
          description: >-
            Whop's published risk index from 0 (lowest) to 100 (highest),
            including enforced decision floors. This is not a fraud probability.
            Null when no score is available.
          example: null
          type:
            - number
            - 'null'
        risk_signals:
          deprecated: true
          description: >-
            Deprecated. Risk score explanations are no longer provided; always
            null.

            DEPRECATED: Risk score explanations are no longer provided. Always
            null.
          example: null
          type:
            - object
            - 'null'
        settlement_time_at:
          description: >-
            When the portion not listed in `holds` posts to the account's
            available balance, at midnight UTC. The
            `financial_activity.funds_available` webhook's `posted_at` carries
            the same value when the settlement that clears it posts. Null until
            the payment is paid, and always null in list responses — retrieve
            the payment for it.
          example: null
          type:
            - string
            - 'null'
        shipment_id:
          description: >-
            The shipment fulfilling this payment, prefixed `ship_`. Null when
            nothing ships or without the shipment:basic:read permission.
          example: null
          type:
            - string
            - 'null'
        shipping_address:
          description: The shipping address for physical goods, or null.
          oneOf:
            - $ref: '#/components/schemas/PaymentAddress'
            - type: 'null'
        status:
          $ref: '#/components/schemas/ReceiptStatus'
          description: >-
            The lifecycle state of the charge: `open` while collection is
            outstanding, `paid` once the money moved, `pending` while a
            settlement rail clears, `void`/`uncollectible` when it ended without
            collecting.
        substatus:
          $ref: '#/components/schemas/FriendlyReceiptStatus'
          description: >-
            The dashboard's finer-grained reading of the payment, folding in
            refunds, disputes and Resolution Center cases.
        subtotal:
          description: The price before discounts, tax and fees.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        tax_amount:
          description: The sales tax or VAT collected. Null when no tax applied.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        tax_behavior:
          description: >-
            Whether `tax_amount` was added on top of the price (`exclusive`) or
            was already inside it (`inclusive`).
          oneOf:
            - $ref: '#/components/schemas/ReceiptTaxBehaviors'
            - type: 'null'
        tax_refunded_amount:
          $ref: '#/components/schemas/Money'
          description: >-
            How much of the collected tax has been returned to the buyer so far.
            Zero when the payment carried no tax, or when nothing has been
            refunded.
        three_ds_verified:
          description: True when the buyer completed 3D Secure for this payment.
          example: false
          type: boolean
        total:
          description: >-
            The account-facing total: the price after discounts, plus any tax
            added on top. Excludes buyer fees, which the buyer pays above this
            amount — so this is not necessarily what the buyer's statement
            shows.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        updated_at:
          description: When the payment last changed, as an ISO 8601 timestamp.
          example: '2026-01-01T12:00:00.000Z'
          type: string
        usd_total:
          description: >-
            The total converted to USD at the time of the charge, for reporting
            across currencies. Excludes the adaptive pricing FX markup, which
            the account does not keep.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
        user:
          description: >-
            The buyer. Null when the payment belongs to a company buyer rather
            than a user.
          oneOf:
            - $ref: '#/components/schemas/UserSummary'
            - type: 'null'
        verification_checks:
          description: >-
            The Address Verification Service (AVS), cardholder name, and Card
            Verification Value (CVV/CVC) results, or null when the processor
            returned none.
          oneOf:
            - $ref: '#/components/schemas/PaymentVerificationChecks'
            - type: 'null'
        voidable:
          description: >-
            True when the payment can be voided or canceled. The request is
            rejected if the payment is no longer eligible — see `POST
            /payments/{id}/void`.
          example: false
          type: boolean
      required:
        - id
        - status
        - substatus
        - billing_reason
        - refundable
        - retryable
        - voidable
        - account_id
        - user
        - member_id
        - membership_id
        - plan_id
        - product_id
        - line_items
        - promo_code_id
        - checkout_configuration_id
        - shipment_id
        - currency
        - total
        - subtotal
        - tax_amount
        - tax_behavior
        - refunded_amount
        - tax_refunded_amount
        - auto_refunded
        - amount_after_fees
        - usd_total
        - payment_method_type
        - payment_method_id
        - payment_instrument
        - customer_email
        - presentment_total
        - customer_phone
        - billing_address
        - shipping_address
        - needs_tracking
        - payments_failed
        - failure_message
        - decline_code
        - recovery_url
        - three_ds_verified
        - verification_checks
        - risk_score
        - payment_rule_matches
        - risk_signals
        - financing_installments_count
        - metadata
        - created_at
        - updated_at
        - paid_at
        - last_payment_attempt_at
        - next_payment_attempt_at
        - refunded_at
        - dispute_alerted_at
        - settlement_time_at
        - holds
        - client_secret
      type: object
    V1ErrorResponse:
      properties:
        error:
          properties:
            code:
              description: >-
                Machine-readable reason for this specific refusal, such as
                `bank_warning_not_acknowledged`. Only present when the error
                carries one.
              type: string
            message:
              description: Human-readable error message.
              example: account_id is required
              type: string
            type:
              description: Machine-readable error code.
              example: bad_request
              type: string
          required:
            - type
            - message
          type: object
      required:
        - error
      type: object
    Money:
      properties:
        amount:
          description: >-
            The amount in major units, as an exact decimal string — `"10.00"` is
            ten dollars. A string so no float rounds it in transit.
          example: '-2.50'
          type: string
        currency:
          description: Three-letter ISO 4217 currency code, lowercase.
          example: usd
          type: string
        decimals:
          description: >-
            How many decimal places the amount CARRIES — the precision the
            charge itself runs at.
          example: 2
          type: integer
        display_decimals:
          description: >-
            How many decimal places to SHOW. Usually equal to `decimals`, and
            deliberately not always: COP is charged in centavos but written in
            whole pesos, so it is `2` and `0`. Format the number in your own
            locale using this.
          example: 2
          type: integer
      required:
        - currency
        - amount
        - decimals
        - display_decimals
      type: object
    PaymentAddress:
      properties:
        city:
          description: The city.
          example: Austin
          type:
            - string
            - 'null'
        country:
          description: The ISO 3166-1 alpha-2 country code.
          example: US
          type:
            - string
            - 'null'
        line1:
          description: The first street address line.
          example: 1114 Bouldin Ave
          type:
            - string
            - 'null'
        line2:
          description: The second street address line.
          example: Unit B
          type:
            - string
            - 'null'
        name:
          description: The name on the address.
          example: Dana Whitfield
          type:
            - string
            - 'null'
        postal_code:
          description: The postal or ZIP code.
          example: '78704'
          type:
            - string
            - 'null'
        state:
          description: The state, province or region.
          example: TX
          type:
            - string
            - 'null'
      required:
        - name
        - line1
        - line2
        - city
        - state
        - postal_code
        - country
      type: object
    BillingReasons:
      description: The reason why a specific payment was billed
      enum:
        - subscription_create
        - subscription_cycle
        - subscription_update
        - one_time
        - manual
        - subscription
      example: subscription_create
      type: string
    Currencies:
      description: The available currencies on the platform
      enum:
        - usd
        - sgd
        - inr
        - aud
        - brl
        - cad
        - dkk
        - eur
        - nok
        - gbp
        - sek
        - chf
        - hkd
        - huf
        - jpy
        - mxn
        - myr
        - pln
        - czk
        - nzd
        - aed
        - eth
        - ape
        - cop
        - ron
        - thb
        - bgn
        - idr
        - dop
        - php
        - try
        - krw
        - twd
        - vnd
        - pkr
        - clp
        - uyu
        - ars
        - zar
        - dzd
        - tnd
        - mad
        - kes
        - kwd
        - jod
        - all
        - xcd
        - amd
        - bsd
        - bhd
        - bob
        - bam
        - khr
        - crc
        - xof
        - egp
        - etb
        - gmd
        - ghs
        - gtq
        - gyd
        - ils
        - jmd
        - mop
        - mga
        - mur
        - mdl
        - mnt
        - nad
        - ngn
        - mkd
        - omr
        - pyg
        - pen
        - qar
        - rwf
        - sar
        - rsd
        - lkr
        - tzs
        - ttd
        - uzs
        - rub
        - btc
        - cny
        - usdt
        - kzt
        - awg
        - whop_usd
        - xau
      example: usd
      type: string
    PaymentDeclineCodes:
      description: The reason a payment was declined.
      enum:
        - insufficient_funds
        - lost_card
        - stolen_card
        - expired_card
        - suspected_fraud
        - invalid_card_number
        - invalid_cvc
        - invalid_cvc_or_expiration
        - incorrect_pin
        - authentication_required
        - card_not_supported
        - currency_not_supported
        - duplicate_transaction
        - generic_decline
        - invalid_account
        - invalid_amount
        - processing_error
        - restricted_card
        - card_velocity_exceeded
        - contact_issuer
        - bank_declined
        - regulatory_blocked
        - transaction_not_permitted
        - transaction_stopped
        - card_type_not_supported
        - issuer_not_found
        - closed_account
        - issuer_unavailable
        - invalid_zip
        - invalid_expiry_month
        - invalid_expiry_year
        - invalid_expiry
        - invalid_transaction
        - cannot_authorize
        - pin_required
        - pin_try_exceeded
        - provider_declined
        - high_risk
        - test_mode_decline
        - merchant_blacklist
        - reenter_transaction
        - invalid_pin
        - pin_required_as
        - withdrawal_count_limit_exceeded
        - invalid_country
        - issuer_error
        - invalid_card_holder_name
        - no_accounts
        - transaction_cancelled
        - three_d_secure_success
        - three_d_secure_canceled
        - three_d_secure_invalid_card_number
        - three_d_secure_generic_error
        - three_d_secure_timeout
        - three_d_secure_failed
        - three_d_secure_card_not_enrolled
        - three_d_secure_fraud
        - three_d_secure_too_many_attempts
        - three_d_secure_rejected_by_bank
        - three_d_secure_reported_lost_or_stolen
        - blocked_by_cardholder
        - test_mode_test_card
        - try_again_later
        - transaction_not_allowed
        - bank_insufficient_funds
        - bank_account_not_found
        - bank_account_closed
        - bank_account_frozen
        - bank_invalid_routing_number
        - bank_non_transaction_account
        - bank_authorization_revoked
        - bank_payment_stopped
        - bank_not_authorized
        - bank_account_holder_deceased
        - bank_duplicate
        - bank_amount_error
        - bank_regulatory_blocked
        - bank_details_invalid
        - bank_processing_error
        - bank_generic_decline
        - sepa_invalid_iban
        - sepa_no_mandate
        - sepa_mandate_data_invalid
        - sepa_disputed
        - sepa_refused_by_customer
        - sepa_generic_decline
      example: insufficient_funds
      type: string
    PaymentHold:
      properties:
        amount:
          $ref: '#/components/schemas/Money'
          description: The amount currently held, in the hold's currency.
        percentage:
          description: >-
            The reserve percentage recorded when the hold was created, for
            example 3.5 for 3.5%. Null for other hold types or when no
            percentage was recorded.
          type:
            - number
            - 'null'
        release_at:
          description: >-
            When the held funds are scheduled to become available, as an ISO
            8601 timestamp. Never earlier than the payment's settlement date.
            Null when release depends on an event, such as shipment resolution,
            rather than a date.
          type:
            - string
            - 'null'
        type:
          description: >-
            The reason funds are held: `reserve`, `bnpl`, `sequra`,
            `fraud_hold`, or `preshipment_hold`.
          enum:
            - reserve
            - bnpl
            - sequra
            - fraud_hold
            - preshipment_hold
          example: reserve
          type: string
      required:
        - type
        - amount
        - percentage
        - release_at
      type: object
    ReceiptLineItem:
      properties:
        id:
          description: >-
            Line item ID, prefixed `li_`. Null when the payment predates item
            snapshots and the item is read from the payment's variant.
          example: li_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        label:
          description: >-
            The item's name as shown at checkout — the product title, else the
            variant title.
          example: Ceramic Coating Package
          type:
            - string
            - 'null'
        plan_id:
          description: >-
            The variant bought, prefixed `plan_`. Null when the variant has
            since been deleted.
          example: plan_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        plan_title:
          description: >-
            The variant's current title, or `null` when the variant has been
            deleted or has no title.
          example: Ceramic Coating — Full Vehicle
          type:
            - string
            - 'null'
        product_id:
          description: >-
            The product the variant belongs to, prefixed `prod_`. On a payment
            that predates item snapshots this falls back to the variant's
            product, so it can be set where the parent's own `product_id` is
            null. Null for a variant with no product.
          example: prod_xxxxxxxxxxxxxx
          type:
            - string
            - 'null'
        product_title:
          description: The product's current title, or `null` when the item has no product.
          example: Ceramic Coating Package
          type:
            - string
            - 'null'
        quantity:
          description: How many units were bought.
          example: 1
          type: number
        subtotal:
          description: >-
            The recorded amount for this item's full quantity, before discounts,
            tax, and fees, in its purchase currency. Returns `null` when no item
            amount was recorded.
          oneOf:
            - $ref: '#/components/schemas/Money'
            - type: 'null'
      required:
        - id
        - plan_id
        - plan_title
        - product_id
        - product_title
        - label
        - quantity
        - subtotal
      type: object
    PaymentInstrument:
      properties:
        card:
          description: >-
            Card payments only: the card's network, last four, and issuer
            identification number.
          oneOf:
            - $ref: '#/components/schemas/PaymentInstrumentCard'
            - type: 'null'
        display_name:
          description: >-
            Buyer-facing instrument name — "Visa •••• 4242" when the card
            surfaced, else the method's own name ("Klarna").
          example: Visa •••• 4242
          type: string
        icons:
          $ref: '#/components/schemas/PaymentMethodIcons'
          description: >-
            The standard icon set: square and card shapes, each in light and
            dark colorways.
        installment_count:
          description: >-
            Installment methods only: how many payments the charge splits into.
            Data, not copy — compose and translate the label client-side.
          example: null
          type:
            - number
            - 'null'
        payment_method_type:
          description: >-
            The payment method type identifier, e.g. `card`, `klarna`,
            `apple_pay`.
          example: card
          type: string
      required:
        - payment_method_type
        - display_name
        - icons
        - card
        - installment_count
      type: object
    PaymentMethodTypes:
      description: The different types of payment methods that can be used.
      enum:
        - acss_debit
        - addi
        - affirm
        - afterpay_clearpay
        - alipay
        - alipayhk
        - alma
        - amazon_pay
        - apple
        - apple_pay
        - au_bank_transfer
        - au_becs_debit
        - bacs_debit
        - bancolombia
        - bancontact
        - bank_wire
        - billie
        - blik
        - boleto
        - bre_b
        - ca_bank_transfer
        - capchase_pay
        - card
        - card_installments_three
        - card_installments_six
        - card_installments_twelve
        - cashapp
        - claritypay
        - coinbase
        - crypto
        - custom
        - customer_balance
        - demo_pay
        - efecty
        - eps
        - eu_bank_transfer
        - fpx
        - flex_pay
        - gb_bank_transfer
        - gcash
        - giropay
        - google_pay
        - gopay
        - grabpay
        - id_bank_transfer
        - ideal
        - interac
        - kakao_pay
        - klarna
        - klarna_pay_now
        - konbini
        - kr_card
        - kr_market
        - kriya
        - kueski
        - link
        - mb_way
        - m_pesa
        - mercado_pago
        - mercado_pago_ar
        - mercado_pago_mx
        - mobilepay
        - modo
        - mondu
        - multibanco
        - naver_pay
        - nequi
        - netbanking
        - ng_bank
        - ng_bank_transfer
        - ng_card
        - ng_market
        - ng_ussd
        - ng_wallet
        - nupay
        - nz_bank_account
        - oney
        - oney_3x
        - oney_4x
        - opay
        - oxxo
        - p24
        - pago_efectivo
        - pse
        - pay_by_bank
        - payco
        - paynow
        - paypal
        - paypay
        - payto
        - pix
        - platform_balance
        - promptpay
        - qris
        - rapipago
        - rechnung
        - revolut_pay
        - samsung_pay
        - satispay
        - scalapay
        - sencillito
        - sepa_debit
        - sequra
        - servipag
        - sezzle
        - shop_pay
        - shopeepay
        - sofort
        - south_korea_market
        - spei
        - splitit
        - sunbit
        - swish
        - tabby
        - tamara
        - touch_n_go
        - twint
        - upi
        - us_bank_account
        - us_bank_transfer
        - venmo
        - verve
        - vipps
        - webpay
        - wechat_pay
        - yape
        - zip
        - coinflow
        - unknown
      example: acss_debit
      type: string
    PaymentRuleMatch:
      properties:
        action:
          description: What the rule asked for.
          enum:
            - allow
            - block
            - review
            - enforce_3ds
          example: allow
          type: string
        id:
          description: Payment rule ID, prefixed `prule_`.
          type: string
        name:
          description: >-
            The rule's name when it matched. Renaming the rule afterwards does
            not rewrite this.
          type:
            - string
            - 'null'
      required:
        - id
        - name
        - action
      type: object
    ReceiptStatus:
      description: The status of a receipt
      enum:
        - draft
        - open
        - authorized
        - paid
        - pending
        - uncollectible
        - unresolved
        - void
      example: draft
      type: string
    FriendlyReceiptStatus:
      description: >-
        The friendly status of a payment. This is a derived status that provides
        a human-readable summary of the payment state, combining the underlying
        status and substatus fields.
      enum:
        - succeeded
        - requires_capture
        - pending
        - failed
        - blocked
        - past_due
        - canceled
        - price_too_low
        - uncollectible
        - refunded
        - auto_refunded
        - partially_refunded
        - dispute_warning
        - dispute_needs_response
        - dispute_warning_needs_response
        - resolution_needs_response
        - dispute_under_review
        - dispute_warning_under_review
        - resolution_under_review
        - dispute_won
        - dispute_warning_closed
        - resolution_won
        - dispute_lost
        - dispute_closed
        - resolution_lost
        - drafted
        - incomplete
        - unresolved
        - open_dispute
        - open_resolution
      example: succeeded
      type: string
    ReceiptTaxBehaviors:
      description: >-
        The type of tax inclusivity applied to the receipt, for determining
        whether the tax is included in the final price, or paid on top.
      enum:
        - exclusive
        - inclusive
        - unspecified
        - unable_to_collect
      example: exclusive
      type: string
    UserSummary:
      properties:
        id:
          description: User ID, prefixed `user_`.
          example: user_xxxxxxxxxxxxxx
          type: string
        name:
          description: Display name.
          example: Dana Whitfield
          type:
            - string
            - 'null'
        profile_picture:
          $ref: '#/components/schemas/UserProfilePicture'
          description: >-
            Avatar wrapper; its `url` is always present, using a generated
            placeholder when the user set no picture.
        username:
          description: Public username.
          example: danawhitfield
          type: string
      required:
        - id
        - username
        - name
        - profile_picture
      type: object
    PaymentVerificationChecks:
      properties:
        address_line1:
          description: >-
            The Address Verification Service (AVS) result for the billing street
            address.
          example: PASS
          type:
            - string
            - 'null'
        authorization_code:
          description: >-
            The card issuer's authorization code for this charge, or null when
            the processor did not return one.
          example: A1B2C3
          type:
            - string
            - 'null'
        card_holder_name:
          description: Whether the cardholder name matched the issuer's records.
          example: PASS
          type:
            - string
            - 'null'
        card_security_code:
          description: The Card Verification Value (CVV/CVC) result.
          example: PASS
          type:
            - string
            - 'null'
        zip_code:
          description: >-
            The Address Verification Service (AVS) result for the billing postal
            code.
          example: PASS
          type:
            - string
            - 'null'
      required:
        - address_line1
        - zip_code
        - card_holder_name
        - card_security_code
        - authorization_code
      type: object
    PaymentInstrumentCard:
      properties:
        brand:
          description: >-
            The network identifier (`visa`, `amex`, …), matching `card.networks`
            entries and saved card payment methods. Null when the vault did not
            record the network.
          example: visa
          type:
            - string
            - 'null'
        exp_month:
          description: >-
            The card's expiry month, 1 to 12. Null when the vault did not record
            it.
          example: 10
          type:
            - number
            - 'null'
        exp_year:
          description: >-
            The card's four-digit expiry year. Null when the vault did not
            record it.
          example: 2031
          type:
            - number
            - 'null'
        issuer_identification_number:
          description: >-
            The issuer identification number, also called the BIN: the card's
            leading six or eight digits, which identify the issuing bank. Null
            when the processor did not report it.
          example: '41111111'
          type:
            - string
            - 'null'
        last4:
          description: The card's last four digits, when captured.
          example: '4242'
          type:
            - string
            - 'null'
      required:
        - brand
        - last4
        - issuer_identification_number
        - exp_month
        - exp_year
      type: object
    PaymentMethodIcons:
      properties:
        card:
          $ref: '#/components/schemas/PaymentMethodIconVariants'
          description: The credit-card-proportioned tile (48x30).
        square:
          $ref: '#/components/schemas/PaymentMethodIconVariants'
          description: The square tile (32x32).
      required:
        - square
        - card
      type: object
    UserProfilePicture:
      properties:
        url:
          description: >-
            Avatar image URL. Always present — a generated placeholder when the
            user set no picture.
          example: https://ui-avatars.com/api/
          type: string
      required:
        - url
      type: object
    PaymentMethodIconVariants:
      properties:
        dark:
          $ref: '#/components/schemas/PaymentMethodIconFiles'
          description: The colorway for dark surfaces.
        light:
          $ref: '#/components/schemas/PaymentMethodIconFiles'
          description: The colorway for light surfaces.
      required:
        - light
        - dark
      type: object
    PaymentMethodIconFiles:
      properties:
        png_1x:
          description: Raster fallback at the shape's native size.
          example: https://content.whop.com/payment_methods/visa/icons/card_dark_30.png
          type: string
        png_2x:
          description: Raster fallback at double density.
          example: https://content.whop.com/payment_methods/visa/icons/card_dark_60.png
          type: string
        png_4x:
          description: Raster fallback at quadruple density.
          example: >-
            https://content.whop.com/payment_methods/visa/icons/card_dark_120.png
          type: string
        svg:
          description: The vector file. Prefer this everywhere SVG renders.
          example: https://content.whop.com/payment_methods/visa/icons/card_dark.svg
          type: string
      required:
        - svg
        - png_1x
        - png_2x
        - png_4x
      type: object
  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
  securitySchemes:
    bearerAuth:
      bearerFormat: auth-scheme
      description: >-
        An Account API key, an App API key, an account access token, an
        account-scoped user token, or a user OAuth token. Prepend the key or
        token with `Bearer`, for example `Bearer ***************************`.
        See [Auth & API keys](/developer/guides/auth-scoping) for how to get
        each one.
      scheme: bearer
      type: http

````