Whop Ruby API Library

https://github.com/whopio/whopsdk-ruby
Admin
A Ruby library providing convenient and type-safe access to the Whop REST API from Ruby 3.2.0+...
Tokens:10,654
Snippets:53
Trust Score:9.1
License:Apache-2.0
Update:11 months ago
Show doc for...
Tokens:
Raw
### Run a Whop SDK Ruby Example

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Executes a Ruby example script from the 'examples/' directory against your API. Ensure the example script has execute permissions.

```ruby
#!/usr/bin/env ruby
# frozen_string_literal: true

require_relative "../lib/whop_sdk"

# ...

```

```bash
# Make the example executable
$ chmod +x './examples/<your-example>.rb'

# Run the example against your API
$ ruby './examples/<your-example>.rb'

```

--------------------------------

### Bootstrap Whop SDK Ruby Project Dependencies

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Installs all necessary dependencies for the Whop SDK Ruby project. This script should be executed after cloning the repository.

```bash
./scripts/bootstrap
```

--------------------------------

### Set up Mock Server for Whop SDK Ruby Tests

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Starts a mock server using Prism against the OpenAPI specification. This is often required to run the project's tests effectively.

```bash
$ npx prism mock path/to/your/openapi.yml
```

--------------------------------

### Preview Documentation for Whop SDK Ruby

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Generates and previews the project's documentation. An optional port can be specified for the preview server.

```bash
$ bundle exec rake docs:preview [PORT=8808]
```

--------------------------------

### Run Tests for Whop SDK Ruby

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Executes the test suite for the Whop SDK Ruby project. Ensure any prerequisites, such as a mock server, are set up before running.

```bash
$ bundle exec rake test
```

--------------------------------

### Install Whop SDK Ruby from Git Repository

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Adds the Whop SDK for Ruby gem to your project's Gemfile, sourcing it directly from its Git repository on GitHub. This is useful for using the latest development version.

```ruby
gem "whop_sdk", git: "https://www.github.com/whopio/whopsdk-ruby"
```

--------------------------------

### Install Whop Ruby SDK Gem

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Add the Whop Ruby SDK gem to your application's Gemfile for installation via Bundler. This ensures you have the latest version of the library for API access.

```ruby
gem "whop_sdk", "~> 0.0.4"
```

--------------------------------

### Run Rake Commands for Whop SDK Ruby

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Executes Rake tasks defined in the project. Running `bundle exec rake` without arguments lists all available commands.

```bash
$ bundle exec rake
```

--------------------------------

### Lint and Typecheck Whop SDK Ruby Project

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Runs linters (RuboCop) and type checkers (Sorbet/Steep) on the Ruby files in the project to ensure code quality and correctness. This command checks for style guide violations and type errors.

```bash
$ bundle exec rake lint
```

--------------------------------

### Manage Promo Codes: Create, Retrieve, List, Archive

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

This section provides Ruby code examples for managing promotional discount codes. It covers creating various types of promo codes (percentage, flat amount, plan-specific) with detailed configurations like duration, user restrictions, and expiration dates. It also shows how to retrieve, list active codes, and archive (delete) them.

```ruby
# Create a percentage discount promo code
promo = whop.promo_codes.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  code: "SUMMER25",
  promo_type: :percentage,
  amount_off: 25.0,  # 25% off
  base_currency: :usd,
  promo_duration_months: 3,
  new_users_only: true,
  one_per_customer: true,
  unlimited_stock: true,
  expires_at: Time.new(2024, 9, 1)
)

# Create a flat amount discount code
flat_promo = whop.promo_codes.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  code: "SAVE10",
  promo_type: :flat,
  amount_off: 10.0,  # $10 off
  base_currency: :usd,
  promo_duration_months: 1,
  new_users_only: false,
  stock: 500,
  unlimited_stock: false
)

# Create promo for specific plans
plan_promo = whop.promo_codes.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  code: "ANNUAL20",
  promo_type: :percentage,
  amount_off: 20.0,
  base_currency: :usd,
  promo_duration_months: 12,
  new_users_only: false,
  plan_ids: ["plan_xxxxxxxxxxxxxx", "plan_yyyyyyyyyyyy"],
  product_id: "prod_xxxxxxxxxxxxxx",
  churned_users_only: false,
  existing_memberships_only: false
)

# Retrieve a promo code
promo_code = whop.promo_codes.retrieve("promo_xxxxxxxxxxxxxx")
puts promo_code.code
puts promo_code.amount_off

# List promo codes
promos_page = whop.promo_codes.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  status: :active,
  product_ids: ["prod_xxxxxxxxxxxxxx"],
  first: 50
)

# Archive (delete) a promo code
deleted = whop.promo_codes.delete("promo_xxxxxxxxxxxxxx")
```

--------------------------------

### Manage Plans: Create, Retrieve, Update, List, Delete

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

This section details how to manage pricing plans for products using the Whop Ruby SDK. Examples include creating recurring, one-time, and sale plans with various configurations like prices, billing periods, trials, and stock limits. It also covers retrieving, updating, listing, and deleting plans.

```ruby
# Create a recurring subscription plan
plan = whop.plans.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  product_id: "prod_xxxxxxxxxxxxxx",
  title: "Monthly Subscription",
  description: "Billed monthly",
  plan_type: :renewal,
  renewal_price: 29.99,
  billing_period: 30,  # days
  currency: :usd,
  trial_period_days: 7,
  visibility: :visible,
  unlimited_stock: true
)

# Create a one-time payment plan
onetime_plan = whop.plans.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  product_id: "prod_xxxxxxxxxxxxxx",
  title: "Lifetime Access",
  plan_type: :one_time,
  initial_price: 299.99,
  currency: :usd,
  stock: 100,
  unlimited_stock: false
)

# Create plan with strike-through pricing
sale_plan = whop.plans.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  product_id: "prod_xxxxxxxxxxxxxx",
  title: "Annual Plan - Limited Time",
  plan_type: :renewal,
  renewal_price: 199.99,
  strike_through_renewal_price: 299.99,
  billing_period: 365,
  currency: :usd
)

# Retrieve a plan
plan = whop.plans.retrieve("plan_xxxxxxxxxxxxxx")
puts plan.title
puts plan.renewal_price

# Update a plan
updated_plan = whop.plans.update(
  "plan_xxxxxxxxxxxxxx",
  renewal_price: 34.99,
  trial_period_days: 14
)

# List plans for a company
plans_page = whop.plans.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  product_ids: ["prod_xxxxxxxxxxxxxx"],
  plan_types: [:renewal, :one_time],
  visibilities: [:visible]
)

# Delete a plan
deleted = whop.plans.delete("plan_xxxxxxxxxxxxxx")
```

--------------------------------

### Use Whop SDK Ruby from Local Cloned Repository

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Allows you to use the Whop SDK for Ruby gem by referencing a local copy of the repository. This is beneficial for development and testing changes.

```bash
# Clone the repository to a local path
$ git clone -- 'https://www.github.com/whopio/whopsdk-ruby' '<path-to-repo>'

```

```ruby
# Reference the local repository in your Gemfile
gem "whop_sdk", path: "<path-to-repo>"
```

--------------------------------

### Handle Whop Webhook Events (Ruby)

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Provides a Ruby example for handling incoming webhook events from Whop. It demonstrates how to unwrap the payload, parse different event types, and implement basic error handling for invalid JSON or processing failures.

```ruby
# In your webhook endpoint (e.g., Rails controller or Sinatra route)
post "/webhooks/whop" do
  payload = request.body.read

  begin
    # Unwrap webhook payload
    event = whop.webhooks.unwrap(payload)

    # Handle different event types
    case event
    when WhopSDK::Models::PaymentSucceededWebhookEvent
      puts "Payment succeeded!"
      puts "Payment ID: #{event.data.id}"
      puts "Amount: #{event.data.amount}"
      # Update your database, send confirmation email, etc.

    when WhopSDK::Models::PaymentFailedWebhookEvent
      puts "Payment failed!"
      puts "Payment ID: #{event.data.id}"
      # Handle failed payment

    when WhopSDK::Models::MembershipActivatedWebhookEvent
      puts "Membership activated!"
      puts "Membership ID: #{event.data.id}"
      puts "User ID: #{event.data.user_id}"
      # Grant access to user

    when WhopSDK::Models::MembershipDeactivatedWebhookEvent
      puts "Membership deactivated!"
      puts "Membership ID: #{event.data.id}"
      # Revoke user access

    when WhopSDK::Models::InvoiceCreatedWebhookEvent
      puts "Invoice created: #{event.data.id}"

    when WhopSDK::Models::InvoicePaidWebhookEvent
      puts "Invoice paid: #{event.data.id}"

    when WhopSDK::Models::CourseLessonInteractionCompletedWebhookEvent
      puts "Lesson completed!"
      puts "User: #{event.data.user_id}"
      puts "Lesson: #{event.data.lesson_id}"

    else
      puts "Unhandled event type: #{event.class.name}"
    end

    status 200
  rescue JSON::ParserError => e
    puts "Invalid JSON payload: #{e.message}"
    status 400
  rescue StandardError => e
    puts "Webhook processing error: #{e.message}"
    status 500
  end
end
```

--------------------------------

### Manage Whop Payments

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Provides examples for interacting with the payment resources of the Whop API. This includes retrieving a specific payment, listing payments with various filters (company ID, status, currency, date range, limit), and performing actions like refunding (full or partial), retrying, and voiding payments.

```ruby
# Retrieve a specific payment by ID
payment = whop.payments.retrieve("pay_xxxxxxxxxxxxxx")
puts payment.id
puts payment.amount
puts payment.status

# List all payments for a company with filters
page = whop.payments.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  statuses: [:succeeded, :pending],
  currencies: [:usd],
  created_after: Time.new(2024, 1, 1),
  created_before: Time.now,
  first: 50  # Limit to first 50 results
)

# Access individual payments
page.data.each do |payment|
  puts "Payment #{payment.id}: $#{payment.amount} - #{payment.status}"
end

# Refund a payment (full refund)
refunded_payment = whop.payments.refund("pay_xxxxxxxxxxxxxx")
puts "Refunded: #{refunded_payment.status}"

# Partial refund
partial_refund = whop.payments.refund(
  "pay_xxxxxxxxxxxxxx",
  partial_amount: 25.50
)

# Retry a failed payment
retried_payment = whop.payments.retry_("pay_xxxxxxxxxxxxxx")

# Void a payment
voided_payment = whop.payments.void("pay_xxxxxxxxxxxxxx")
```

--------------------------------

### Provide Typesafe Request Parameters with Sorbet (Ruby)

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Shows how to use Sorbet for typesafe request parameters in the Whop SDK for Ruby. It includes examples of directly passing parameters and using a `Params` class with splatting for type safety.

```ruby
whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")
```

```ruby
# Hashes work, but are not typesafe:
whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")

# You can also splat a full Params class:
params = WhopSDK::PaymentListParams.new(company_id: "biz_xxxxxxxxxxxxxx")
whop.payments.list(**params)
```

--------------------------------

### Format and Fix Lint Issues in Whop SDK Ruby

Source: https://github.com/whopio/whopsdk-ruby/blob/main/CONTRIBUTING.md

Automatically formats Ruby code and fixes linting issues detected by tools like RuboCop and Syntax Tree. This command helps maintain consistent code style across the project.

```bash
$ bundle exec rake format
```

--------------------------------

### Make Custom Requests to Undocumented Endpoints in Ruby

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Illustrates how to use the `whop.request` method in the Ruby SDK to interact with undocumented API endpoints. Examples cover making custom POST, GET, PUT, and DELETE requests, including specifying paths, query parameters, headers, and request bodies.

```ruby
# Make a custom POST request to an undocumented endpoint
response = whop.request(
  method: :post,
  path: "/undocumented/endpoint",
  query: { filter: "active", limit: 50 },
  headers: { "X-Custom-Header" => "value" },
  body: {
    data: "custom payload",
    options: {
      flag: true,
      count: 10
    }
  }
)

# Make a custom GET request
response = whop.request(
  method: :get,
  path: "/internal/stats",
  query: { period: "monthly", year: 2024 }
)

# Custom PUT request
response = whop.request(
  method: :put,
  path: "/resources/#{resource_id}/settings",
  body: { enabled: true, threshold: 100 }
)

# Custom DELETE request
response = whop.request(
  method: :delete,
  path: "/cache/clear",
  query: { scope: "all" }
)
```

--------------------------------

### Handle Whop API Errors with Typed Exceptions in Ruby

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Demonstrates how to catch and handle specific Whop API errors using Ruby's begin-rescue blocks. It covers various error types from connection issues to rate limiting and server errors, providing examples of how to access error messages and status codes for informed error management.

```ruby
begin
  payment = whop.payments.retrieve("pay_xxxxxxxxxxxxxx")
  puts "Payment amount: #{payment.amount}"

rescue WhopSDK::Errors::APIConnectionError => e
  # Network/connection errors
  puts "Cannot reach server: #{e.message}"
  puts "Underlying error: #{e.cause}"
  # Retry with exponential backoff or alert monitoring

rescue WhopSDK::Errors::APITimeoutError => e
  # Request timeout
  puts "Request timed out: #{e.message}"
  # Retry with increased timeout

rescue WhopSDK::Errors::AuthenticationError => e
  # HTTP 401 - Invalid API key
  puts "Authentication failed: #{e.message}"
  puts "Status code: #{e.status}"
  # Check API key configuration

rescue WhopSDK::Errors::PermissionDeniedError => e
  # HTTP 403 - Insufficient permissions
  puts "Permission denied: #{e.message}"
  # Check app permissions in Whop dashboard

rescue WhopSDK::Errors::NotFoundError => e
  # HTTP 404 - Resource not found
  puts "Resource not found: #{e.message}"
  # Handle missing resource

rescue WhopSDK::Errors::RateLimitError => e
  # HTTP 429 - Too many requests
  puts "Rate limit exceeded: #{e.message}"
  # Back off and retry after delay
  sleep(5)
  retry

rescue WhopSDK::Errors::BadRequestError => e
  # HTTP 400 - Invalid request parameters
  puts "Bad request: #{e.message}"
  puts "Status: #{e.status}"

rescue WhopSDK::Errors::ConflictError => e
  # HTTP 409 - Resource conflict
  puts "Conflict: #{e.message}"

rescue WhopSDK::Errors::UnprocessableEntityError => e
  # HTTP 422 - Validation error
  puts "Validation error: #{e.message}"

rescue WhopSDK::Errors::InternalServerError => e
  # HTTP 5xx - Server error
  puts "Server error: #{e.message}"
  # Retry with backoff

rescue WhopSDK::Errors::APIStatusError => e
  # Other HTTP errors
  puts "API error: #{e.message}"
  puts "Status code: #{e.status}"

rescue WhopSDK::Errors::APIError => e
  # Base error class - catches all API errors
  puts "API error occurred: #{e.message}"
end
```

--------------------------------

### Initialize Whop Ruby SDK Client

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Demonstrates how to initialize the Whop Ruby SDK client using environment variables or explicit credentials. It also shows how to configure request timeouts, maximum retries, and a custom base URL.

```ruby
require "whop_sdk"

# Initialize with environment variables (default)
whop = WhopSDK::Client.new(
  api_key: ENV["WHOP_API_KEY"],  # Required: Your app API key
  app_id: ENV["WHOP_APP_ID"]     # Required: Your app ID
)

# Initialize with explicit credentials
whop = WhopSDK::Client.new(
  api_key: "your_api_key_here",
  app_id: "app_xxxxxxxxxxxxxx"
)

# Configure timeouts and retries
whop = WhopSDK::Client.new(
  api_key: ENV["WHOP_API_KEY"],
  app_id: ENV["WHOP_APP_ID"],
  timeout: 30,        # Request timeout in seconds (default: 60)
  max_retries: 5,     # Max retry attempts (default: 2)
  base_url: "https://api.whop.com/api/v1"  # Optional custom base URL
)
```

--------------------------------

### Manage Products: Create, Retrieve, Update, List, Delete

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

This section covers the full lifecycle management of products via the Whop Ruby SDK. It includes creating new products with detailed attributes, retrieving existing ones, updating their details, listing products associated with a company, and deleting products.

```ruby
# Create a new product
product = whop.products.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  title: "Premium Membership",
  description: "Access to all premium content and features",
  headline: "Unlock Premium Features",
  visibility: :visible,
  business_type: :software,
  industry_type: :education,
  experience_ids: ["exp_xxxxxxxxxxxxxx"],
  collect_shipping_address: false,
  global_affiliate_status: :enabled,
  global_affiliate_percentage: 10.0,
  member_affiliate_status: :enabled,
  member_affiliate_percentage: 5.0,
  custom_cta: :subscribe,
  custom_cta_url: "https://example.com/subscribe",
  redirect_purchase_url: "https://example.com/success"
)

puts "Created product: #{product.id}"

# Retrieve a product
product = whop.products.retrieve("prod_xxxxxxxxxxxxxx")
puts product.title
puts product.description

# Update a product
updated_product = whop.products.update(
  "prod_xxxxxxxxxxxxxx",
  title: "Premium Plus Membership",
  description: "Enhanced premium access",
  visibility: :hidden
)

# List products for a company
products_page = whop.products.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  visibilities: [:visible],
  product_types: [:standard],
  first: 25
)

products_page.data.each do |product|
  puts "Product: #{product.title} (#{product.id})"
end

# Delete a product
deleted = whop.products.delete("prod_xxxxxxxxxxxxxx")
puts "Product deleted: #{deleted}"  # Returns true if successful
```

--------------------------------

### Initialize Whop Ruby SDK Client and List Payments

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Demonstrates how to initialize the Whop SDK client with an API key and app ID, and then use it to list payments for a specific company. The API key defaults to the WHOP_API_KEY environment variable. This is the fundamental step for interacting with the Whop API.

```ruby
require "bundler/setup"
require "whop_sdk"

whop = WhopSDK::Client.new(
  api_key: ENV["WHOP_API_KEY"], # This is the default and can be omitted
  app_id: "app_xxxxxxxxxxxxxx"
)

page = whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")

puts(page.id)
```

--------------------------------

### Retrieve and Check User Access with Whop SDK (Ruby)

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Demonstrates how to retrieve user information by ID or username and check if a user has access to a specific resource using the Whop SDK. It shows how to output user details and access validation status.

```ruby
# Retrieve a user by ID or username
user = whop.users.retrieve("user_xxxxxxxxxxxxxx")
puts user.id
puts user.username
puts user.email

# Check if user has access to a resource
access_check = whop.users.check_access(
  "prod_xxxxxxxxxxxxxx",  # resource_id
  id: "user_xxxxxxxxxxxxxx"
)

puts "Has access: #{access_check.valid}"
puts "Access level: #{access_check.access_level}"

if access_check.valid
  puts "User has access to this resource"
  puts "Access granted via: #{access_check.membership_id}"
else
  puts "User does not have access"
end
```

--------------------------------

### Handle Pagination in Whop SDK

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Illustrates how to handle paginated results from the Whop API. It covers automatic pagination using `auto_paging_each` to iterate through all items across multiple pages, and manual pagination using `next_page` to fetch pages sequentially. Cursor-based pagination with `after` and `first` parameters is also demonstrated.

```ruby
# Automatic pagination with auto_paging_each
page = whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")

# Fetch all pages automatically
page.auto_paging_each do |payment|
  puts payment.id
  puts payment.amount
  puts payment.created_at
end

# Manual pagination using next_page
current_page = whop.memberships.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  first: 25
)

# Access first page data
current_page.data.each do |membership|
  puts membership.id
end

# Check if there's a next page and fetch it
if current_page.next_page?
  next_page = current_page.next_page
  next_page.data.each do |membership|
    puts membership.id
  end
end

# Pagination with cursors
page = whop.products.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  after: "cursor_string",   # Start after this cursor
  first: 10                 # Get first 10 items
)
```

--------------------------------

### Manage Whop Memberships

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Shows how to manage membership resources via the Whop API. Includes retrieving a membership by ID or license key, listing memberships with filters (company ID, status, plan IDs, user IDs, date range), and updating membership metadata. Demonstrates canceling memberships immediately or at the end of the billing period.

```ruby
# Retrieve a membership by ID or license key
membership = whop.memberships.retrieve("mem_xxxxxxxxxxxxxx")
puts membership.id
puts membership.user_id
puts membership.status
puts membership.plan_id
puts membership.expires_at

# List memberships with filters
memberships_page = whop.memberships.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  statuses: [:active, :trialing],
  plan_ids: ["plan_xxxxxxxxx", "plan_yyyyyyyyy"],
  user_ids: ["user_xxxxxxxxxxxxxx"],
  created_after: Time.new(2024, 1, 1),
  first: 50
)

memberships_page.auto_paging_each do |membership|
  puts "Membership #{membership.id} - Status: #{membership.status}"
end

# Update membership metadata
updated_membership = whop.memberships.update(
  "mem_xxxxxxxxxxxxxx",
  metadata: {
    custom_field: "value",
    tier: "premium",
    notes: "VIP customer"
  }
)

# Cancel a membership immediately
cancelled = whop.memberships.cancel(
  "mem_xxxxxxxxxxxxxx",
  cancellation_mode: :immediately
)

# Cancel at end of billing period
cancelled_later = whop.memberships.cancel(
  "mem_xxxxxxxxxxxxxx",
  cancellation_mode: :at_period_end
)
```

--------------------------------

### Verify User JWT Tokens with Whop SDK (Ruby)

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Illustrates how to verify JWT user tokens received from Whop's iframe proxy. It covers verification from request headers, raw token strings, and handling potential errors during the process.

```ruby
# Verify user token from request headers
begin
  # From hash of headers
  payload = whop.verify_user_token!(
    request.headers,  # Pass entire headers hash
    app_id: "app_xxxxxxxxxxxxxx"
  )

  puts "Authenticated user: #{payload.user_id}"
  puts "App ID: #{payload.app_id}"

  # Use user_id to fetch user data or check permissions
  user = whop.users.retrieve(payload.user_id)
rescue StandardError => e
  puts "Token verification failed: #{e.message}"
  # Handle authentication error
end

# Verify token from string
token_string = "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9..."
payload = whop.verify_user_token!(
  token_string,
  app_id: "app_xxxxxxxxxxxxxx"
)

# Safe verification that returns nil on failure
payload = whop.verify_user_token(request.headers)
if payload
  puts "User authenticated: #{payload.user_id}"
else
  puts "Authentication failed"
end

# Custom header name
payload = whop.verify_user_token!(
  request.headers,
  header_name: "x-custom-token-header"
)

# Using the helper module directly
require "whop_sdk/helpers/verify_user_token"

token = WhopSDK::Helpers::VerifyUserToken.get_user_token(
  request.headers,
  header_name: "x-whop-user-token"
)

payload = WhopSDK::Helpers::VerifyUserToken.verify_user_token!(
  token,
  app_id: "app_xxxxxxxxxxxxxx"
)
```

--------------------------------

### Handling Undocumented Properties and Parameters

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Demonstrates how to send undocumented query, body, and header parameters to any endpoint and how to access undocumented response properties.

```APIDOC
## Sending Undocumented Parameters

### Description
This section explains how to include extra, undocumented parameters in your API requests.

### Method
POST (example, applicable to various methods)

### Endpoint
Any whop SDK endpoint (e.g., `/payments`)

### Parameters
#### Request Body
- **request_options** (object) - Optional - An object to encapsulate extra parameters.
  - **extra_query** (object) - Optional - Key-value pairs for undocumented query parameters.
  - **extra_body** (object) - Optional - Key-value pairs for undocumented request body parameters.
  - **extra_headers** (object) - Optional - Key-value pairs for undocumented headers.

### Request Example
```ruby
page = whop.payments.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  request_options: {
    extra_query: {my_query_parameter: "value"},
    extra_body: {my_body_parameter: "value"},
    extra_headers: {"my-header": "value"}
  }
)
```

### Response
#### Success Response (200)
- **my_undocumented_property** (any) - Description of the undocumented property.

#### Response Example
```ruby
puts(page[:my_undocumented_property])
```
```

--------------------------------

### Configure Timeouts for Whop Ruby SDK Requests

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Demonstrates how to set the request timeout for the Whop Ruby SDK client. This can be configured globally during client initialization or on a per-request basis to manage how long the client waits for a response.

```ruby
# Configure the default for all requests:
whop = WhopSDK::Client.new(
  timeout: nil, # default is 60
  app_id: "app_xxxxxxxxxxxxxx"
)

# Or, configure per-request:
whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx", request_options: {timeout: 5})
```

--------------------------------

### Making Requests to Undocumented Endpoints

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Shows how to make direct requests to undocumented API endpoints using the `client.request` method, preserving authentication and other SDK features.

```APIDOC
## Undocumented Endpoints

### Description
This section details how to interact with API endpoints that are not explicitly defined within the SDK.

### Method
POST (example, but can be any HTTP method)

### Endpoint
`/undocumented/endpoint`

### Parameters
#### Path Parameters
None specified in example.

#### Query Parameters
- **dog** (string) - Optional - Example query parameter.

#### Request Body
- **hello** (string) - Optional - Example request body parameter.

#### Headers
- **useful-header** (string) - Optional - Example custom header.

### Request Example
```ruby
response = client.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)
```

### Response
#### Success Response (200)
- **(structure depends on the undocumented endpoint)**

#### Response Example
```ruby
# Response structure is specific to the endpoint called
puts(response)
```
```

--------------------------------

### Customize Whop API Requests with Options in Ruby

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Shows how to apply per-request options in the Whop Ruby SDK, including setting custom timeouts, configuring retry attempts, and sending undocumented query parameters, body parameters, or headers. It also demonstrates accessing undocumented response properties.

```ruby
# Per-request timeout override
payment = whop.payments.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  request_options: {
    timeout: 10  # 10 second timeout for this request only
  }
)

# Per-request retry configuration
membership = whop.memberships.retrieve(
  "mem_xxxxxxxxxxxxxx",
  request_options: {
    max_retries: 5  # Retry up to 5 times for this request
  }
)

# Send undocumented query parameters
page = whop.payments.list(
  company_id: "biz_xxxxxxxxxxxxxx",
  request_options: {
    extra_query: { debug: true, include_metadata: true }
  }
)

# Send undocumented body parameters
product = whop.products.create(
  company_id: "biz_xxxxxxxxxxxxxx",
  title: "New Product",
  request_options: {
    extra_body: { custom_field: "value" }
  }
)

# Send custom headers
plan = whop.plans.retrieve(
  "plan_xxxxxxxxxxxxxx",
  request_options: {
    extra_headers: { "X-Custom-Header" => "custom-value" }
  }
)

# Access undocumented response properties
page = whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")
undocumented_value = page[:my_undocumented_property]
```

--------------------------------

### Manage Memberships: Pause and Resume

Source: https://context7.com/whopio/whopsdk-ruby/llms.txt

Demonstrates how to pause and resume memberships using the Whop Ruby SDK. Pausing a membership can optionally void past-due payments. Resuming a paused membership restores access.

```ruby
# Pause a membership
paused = whop.memberships.pause(
  "mem_xxxxxxxxxxxxxx",
  void_payments: true  # Void any past_due payments
)

# Resume a paused membership
resumed = whop.memberships.resume("mem_xxxxxxxxxxxxxx")
```

--------------------------------

### Type-Safe Parameters with Sorbet

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Illustrates how to use Sorbet for type safety when defining request parameters, including the use of Params classes and tagged symbols for enums.

```APIDOC
## Sorbet Integration

### Description
This section covers how to leverage Sorbet for compile-time type checking with the Whop SDK.

### Providing Type-Safe Request Parameters

#### Using Direct Hash (Less Type-Safe)
```ruby
whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")
```

#### Using Params Class (More Type-Safe)
```ruby
params = WhopSDK::PaymentListParams.new(company_id: "biz_xxxxxxxxxxxxxx")
whop.payments.list(**params)
```

### Enums (Tagged Symbols)

#### Description
Since the SDK does not depend on `sorbet-runtime`, enums are represented as tagged symbols.

#### Example Usage
```ruby
# Accessing an enum constant
puts(WhopSDK::AppStatuses::LIVE)

# Using enum constants in requests
whop.apps.update(
  status: WhopSDK::AppStatuses::LIVE,
  # ... other parameters
)

# Using literal values is also permissible
whop.apps.update(
  status: :live,
  # ... other parameters
)
```
```

--------------------------------

### Send Undocumented Parameters to Endpoints (Ruby)

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Demonstrates sending undocumented parameters to an API endpoint using the Whop SDK for Ruby. It shows how to pass extra query, body, and header parameters via `request_options` and how to access undocumented response properties.

```ruby
page =
  whop.payments.list(
    company_id: "biz_xxxxxxxxxxxxxx",
    request_options: {
      extra_query: {my_query_parameter: value},
      extra_body: {my_body_parameter: value},
      extra_headers: {"my-header": value}
    }
  )

puts(page[:my_undocumented_property])
```

--------------------------------

### Handle Whop API Errors with Ruby

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Provides a robust error handling strategy for API interactions using the Whop Ruby SDK. It demonstrates catching specific subclasses of `WhopSDK::Errors::APIError` for different HTTP status codes and network issues.

```ruby
begin
  payment = whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")
rescue WhopSDK::Errors::APIConnectionError => e
  puts("The server could not be reached")
  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
rescue WhopSDK::Errors::RateLimitError => e
  puts("A 429 status code was received; we should back off a bit.")
rescue WhopSDK::Errors::APIStatusError => e
  puts("Another non-200-range status code was received")
  puts(e.status)
end
```

--------------------------------

### Paginate Whop API Responses with Auto-Paging

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Shows how to handle paginated API responses using the Whop Ruby SDK's auto-paging feature. This allows iterating through all items across multiple pages without manual page requests. It also demonstrates accessing the first item on the current page.

```ruby
page = whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx")

# Fetch single item from page.
payment = page.data[0]
puts(payment.id)

# Automatically fetches more pages as needed.
page.auto_paging_each do |payment|
  puts(payment.id)
end
```

--------------------------------

### Manually Paginate Whop API Responses

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Illustrates manual pagination control for Whop API responses using `#next_page?` and `#next_page`. This approach provides granular control over fetching subsequent pages when auto-paging is not desired.

```ruby
if page.next_page?
  new_page = page.next_page
  puts(new_page.data[0].id)
end
```

--------------------------------

### Configure Retries for Whop Ruby SDK Requests

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Explains how to configure the number of automatic retries for API requests made through the Whop Ruby SDK. It shows setting a default for all requests or specifying retries on a per-request basis.

```ruby
# Configure the default for all requests:
whop = WhopSDK::Client.new(
  max_retries: 0, # default is 2
  app_id: "app_xxxxxxxxxxxxxx"
)

# Or, configure per-request:
whop.payments.list(company_id: "biz_xxxxxxxxxxxxxx", request_options: {max_retries: 5})
```

--------------------------------

### Make Requests to Undocumented Endpoints (Ruby)

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Illustrates how to make requests to undocumented API endpoints using the `client.request` method in the Whop SDK for Ruby. This method allows for custom HTTP methods, paths, query parameters, headers, and bodies while retaining SDK benefits like authentication and retries.

```ruby
response = client.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)
```

--------------------------------

### Use Tagged Symbols for Enums with Sorbet (Ruby)

Source: https://github.com/whopio/whopsdk-ruby/blob/main/README.md

Explains how the Whop SDK for Ruby uses "tagged symbols" instead of `T::Enum` due to the lack of `sorbet-runtime` dependency. It demonstrates accessing enum constants and passing either the constant or its literal value for enum parameters.

```ruby
# :live
puts(WhopSDK::AppStatuses::LIVE)

# Revealed type: `T.all(WhopSDK::AppStatuses, Symbol)`
T.reveal_type(WhopSDK::AppStatuses::LIVE)
```

```ruby
# Using the enum constants preserves the tagged type information:
whop.apps.update(
  status: WhopSDK::AppStatuses::LIVE,
  # …
)

# Literal values are also permissible:
whop.apps.update(
  status: :live,
  # …
)
```
Tokens:
Raw