paddle 2.9 → 3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc578ecefeacc14fa58ae9fc433429c3180d5c5bc6015493bc66afc50172cccd
-  data.tar.gz: 03d85b6ee1f8fedb0c5b56028dfb741d32155471bfda087b7cf61bd2872f60ef
+  metadata.gz: ae96654d26047a02fed95576d33befa70e04ae3103e4f191de9f8a8a6e71bdb8
+  data.tar.gz: 3e434eabe578af9f29e9fd543b829a691f8afc8b2c6f4cb2fbf1f9334a75ea97
 SHA512:
-  metadata.gz: 4ecdcde91d5d11a03c7f5e1506f923b3cfd738bbc70113436891768e2cdbdc194694a67e9e452256b6d8be5918b0eed315ce27ab9e5a7a5920312023f3ed3acc
-  data.tar.gz: 851daa7f4a126c94891cf136b80761f7a98745cd3a21455cadb8af1e7f782f3972a8e0123585320052d6335bd25598706e212e1224aaabd93c18c100f195c16b
+  metadata.gz: abc283ed4ca2bda5cc36ff72c576fafeba7b858ed4a87b807ead8187c276690b8f995e8f6be51be41f8ac7dab90d897e43a7aca5baea38eb227465f956ef1aa3
+  data.tar.gz: 53f563a9dec92f02717c6cf46a953fd31f605b8888ca04e6e1b61c488a6372ec94f1703aad21e43a9198da7c265689e4046b29613e76a5728de9d0fa2bf2b5a5

data/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+## 3.0 - 2026-09-27
+
+### Breaking changes
+
+- **Ruby 3.3 or later is required.** Ruby 3.2 has reached end of life.
+- **Responses are no longer OpenStructs.** `Paddle::Object` is now a lightweight class, and nested objects are
+  `Paddle::Object` rather than `OpenStruct`. Dot access, hash access (`obj[:id]`, `obj["id"]`), setters, `nil` for
+  missing attributes, `each_pair` and `update` work as before. Code that checks `is_a?(OpenStruct)` or uses
+  OpenStruct-only methods, such as `delete_field` or `to_h` with a block, will need updating. Attributes named after
+  built-in methods, such as `hash` or `class`, need to be read with `obj[:hash]`.
+- **`to_h` now converts nested objects to hashes too**, rather than only the top level.
+- **The `ostruct` and `cgi` dependencies have been removed.** If your app uses either and relied on this gem to install
+  it, add it to your Gemfile.
+- **Every non-2xx response now raises an error.** Previously only a fixed list of status codes raised, so responses
+  like 422, 502 and 504 were returned as if they'd succeeded. Non-JSON error bodies, such as an HTML page from a
+  gateway, also raise now rather than causing a `NoMethodError`.
+- **The environment is detected from the API key.** Keys starting with `pdl_live_` or `pdl_sdbx_` set the environment
+  automatically, so a sandbox key with no environment set now goes to the sandbox rather than production. Setting an
+  environment that doesn't match the key raises an `ArgumentError`. Older keys without a prefix behave as before.
+- **Config changes take effect straight away.** The connection used to keep the API key, environment, version and
+  connection options from the first request, so later changes were ignored.
+- **Array query params are sent as comma-separated lists**, e.g. `status=active,past_due`, as Paddle expects. They
+  were sent as `status[]=active&status[]=past_due`, which Paddle didn't read as intended.
+- `ServiceUnavailableError` (503) now says the API is temporarily unavailable, rather than describing a rate limit.
+  Rate limits are raised as `TooManyRequestsError` (429).
+
+### Added
+
+- `Paddle.with_config` to make requests with a different API key, environment or version, such as for another
+  Paddle account. It's safe to use in multi-threaded servers and job runners.
+- `Paddle::Webhook` for verifying webhook signatures, with `verify!`, `valid?` and `construct_event`.
+- `Paddle::Metric` for the metrics API: `monthly_recurring_revenue`, `monthly_recurring_revenue_change`,
+  `active_subscribers`, `revenue`, `refunds`, `chargebacks` and `checkout_conversion`.
+- The Explore metrics API, with `Metric.explore_entities` and `Metric.explore`.
+- `Collection#has_more?`, `next_page` and `auto_paging_each` for paging through results.
+- `skip_count: true` on any list method, to skip counting results for faster responses.
+- `Subscription.history`, `Subscription.charge_preview` and `Transaction.revise`.
+- `Customer.credit_balances` to return the credit balance for every currency.
+- `Notification.replay` has been restored.
+- `Adjustment.create` no longer needs `items:` when `type: "full"` is given.
+- `Simulation.runs` and `SimulationRun.events` accept pagination params.
+- `Paddle::Object#to_json`, `as_json`, `dig` and `key?`.
+
+### Changed
+
+- Building response objects is around 20x faster and uses around 20x less memory.
+- Faraday 2.14.3 or later is required, for [GHSA-98m9-hrrm-r99r](https://github.com/advisories/GHSA-98m9-hrrm-r99r).
+- The repository has moved to [d34ndev/paddle](https://github.com/d34ndev/paddle).
+- The Classic API docs have moved to [docs/classic.md](docs/classic.md), and now cover every Classic endpoint.
+
+### Fixed
+
+- `delete_request` passed headers to Faraday as query params.
+- Calling `update` on an object whose model doesn't support updating now raises a `NoMethodError`.
+
+## Earlier versions
+
+See the [releases on GitHub](https://github.com/d34ndev/paddle/releases) for versions before 3.0.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-2026 Dean Perry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -2,12 +2,14 @@
 
 The easiest and most complete Ruby library for the Paddle APIs, both Classic and Billing.
 
+Using Paddle Classic? See the [Classic API docs](docs/classic.md).
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "paddle", "~> 2.8"
+gem "paddle", "~> 3.0"
 ```
 
 ## Billing API
@@ -33,12 +35,75 @@ Paddle.configure do |config|
 end
 ```
 
+API keys created since May 2025 start with `pdl_live_` or `pdl_sdbx_`, so the environment is detected from the key and you don't need to set it:
+
+```ruby
+Paddle.configure do |config|
+  config.api_key = "pdl_sdbx_apikey_..."
+end
+
+Paddle.config.environment
+#=> :sandbox
+```
+
+If you do set an environment that doesn't match the key, such as `:production` with a `pdl_sdbx_` key,
+an `ArgumentError` is raised straight away, since those requests would always fail. Older API keys don't have a prefix, so set the environment for them as before. It defaults to `:production`.
+
+### Using Multiple API Keys
+
+To make requests with a different API key, environment or version, such as for another Paddle account,
+wrap them in `Paddle.with_config`. Everything in the block uses the given options over the global config:
+
+```ruby
+Paddle.with_config(api_key: account.paddle_api_key) do
+  Paddle::Subscription.list(status: "active")
+end
+
+# Blocks can be nested, and you can change the environment or version too
+Paddle.with_config(api_key: "pdl_live_apikey_...", version: 1) do
+  Paddle::Product.list
+end
+```
+
+When a new API key is given without an environment, the environment is detected from the key. For older keys without a prefix, the current environment is kept.
+
+The config is stored per thread and fiber, so it's safe to use in multi-threaded servers like Puma and job
+runners like Sidekiq. Concurrent requests never see each other's keys. Threads and fibers started inside the block use the same config. `Paddle.configure` always changes the global config, even inside a block.
+
+### Connection Options
+
+You can pass [options](https://lostisland.github.io/faraday/#/customization/connection-options) to the underlying [Faraday](https://lostisland.github.io/faraday/) connection using `connection_options`. This is useful for setting timeouts, proxies, or SSL configuration:
+
+```ruby
+Paddle.configure do |config|
+  config.environment = :sandbox
+  config.api_key = ENV["PADDLE_API_KEY"]
+
+  config.connection_options = {
+    request: { timeout: 10, open_timeout: 5 }
+  }
+end
+```
+
 ### Resources
 
 The gem maps as closely as we can to the Paddle API so you can easily convert API examples to gem code.
 
-Responses are created as objects like `Paddle::Product`. Having types like `Paddle::Product` is handy for understanding what
-type of object you're working with. They're built using OpenStruct so you can easily access data in a Ruby-ish way.
+Responses are created as objects like `Paddle::Product`. Having types like `Paddle::Product` is handy for understanding what type of object you're working with. Attributes can be read with dot notation or like a hash, and nested data is wrapped too:
+
+```ruby
+transaction = Paddle::Transaction.retrieve(id: "txn_abc123")
+
+transaction.status                          #=> "completed"
+transaction[:status]                        #=> "completed"
+transaction.details.totals.total            #=> "1000"
+transaction.dig(:items, 0, :price, :id)     #=> "pri_abc123"
+transaction.missing_attribute               #=> nil
+
+# Convert back to a hash or JSON, including nested data
+transaction.to_h
+transaction.to_json
+```
 
 ### Pagination
 
@@ -51,8 +116,14 @@ results = Paddle::Product.list(per_page: 10)
 #=> Paddle::Collection
 
 results.total
+#=> 42
+
+results.per_page
 #=> 10
 
+results.has_more?
+#=> true
+
 results.data
 #=> [#<Paddle::Product>, #<Paddle::Product>]
 
@@ -66,9 +137,37 @@ results.first
 results.last
 #=> #<Paddle::Product>
 
-# Retrieve the next page
+# Retrieve the next page. Returns nil when there are no more pages
+results.next_page
+#=> Paddle::Collection
+
+# Or use the after cursor directly
 Paddle::Product.list(per_page: 10, after: "abc123")
 #=> Paddle::Collection
+
+# Iterate over every result across all pages, fetching each page as it's needed
+Paddle::Product.list(per_page: 50).auto_paging_each do |product|
+  puts product.id
+end
+
+# Without a block, auto_paging_each returns an Enumerator. Pages are only fetched until a match is found
+Paddle::Customer.list.auto_paging_each.find { |customer| customer.email == "michael@mycompany.com" }
+```
+
+>[!NOTE]
+>
+> `total` is Paddle's `estimated_total`. For lists of more than 100,000 results it's capped at `100001`,
+> and it's `-1` when Paddle can't count the results. Use `has_more?`, `next_page` or `auto_paging_each`
+> to page through results rather than relying on `total`.
+
+If you don't need `total`, pass `skip_count: true` to any list method. This sends the `Skip-Count` header,
+so Paddle skips counting the results and responds faster. `total` will be `-1`, and `next_page` and
+`auto_paging_each` keep sending the header for later pages.
+
+```ruby
+Paddle::Transaction.list(skip_count: true).auto_paging_each do |transaction|
+  puts transaction.id
+end
 ```
 
 ### Caveats
@@ -77,6 +176,14 @@ Paddle::Product.list(per_page: 10, after: "abc123")
 >
 > The Paddle API doesn't take `nil` values for optional parameters. If you want to remove a value, you'll need to pass `"null"` instead.
 
+When filtering a list, you can pass an array or a comma-separated string to filter by more than one value. Arrays are sent as comma-separated lists, as Paddle expects:
+
+```ruby
+Paddle::Subscription.list(status: [ "active", "past_due" ])
+# is the same as
+Paddle::Subscription.list(status: "active,past_due")
+```
+
 ### Error Handling
 
 When API requests fail, the gem provides detailed error information to help you debug issues. Errors are raised as exceptions with comprehensive details including field-level validation errors.
@@ -84,6 +191,7 @@ When API requests fail, the gem provides detailed error information to help you
 #### Error Structure
 
 All errors inherit from `Paddle::ErrorGenerator` and include:
+
 - HTTP status code
 - Error code from Paddle
 - Detailed error message
@@ -100,6 +208,7 @@ All errors inherit from `Paddle::ErrorGenerator` and include:
 - `Paddle::Errors::ConflictError` (409) - Request conflicts with existing data
 - `Paddle::Errors::TooManyRequestsError` (429) - Rate limit exceeded
 - `Paddle::Errors::InternalError` (500) - Server error
+- `Paddle::Errors::NotImplementedError` (501) - Resource not implemented
 - `Paddle::Errors::ServiceUnavailableError` (503) - Service unavailable
 
 #### Error Example
@@ -275,8 +384,12 @@ customer.update(status: "archived")
 # or
 Paddle::Customer.update(id: "ctm_abc123", status: "archived")
 
-# Retrieve credit balance for a customer
+# List credit balances for a customer. Customers have a balance for each currency
 # https://developer.paddle.com/api-reference/customers/list-credit-balances
+Paddle::Customer.credit_balances(id: "ctm_abc123")
+Paddle::Customer.credit_balances(id: "ctm_abc123", currency_code: "USD")
+
+# Retrieve the first credit balance for a customer
 Paddle::Customer.credit(id: "ctm_abc123")
 
 # Generate an authentication token for a customer
@@ -348,21 +461,32 @@ Paddle::Transaction.retrieve(id: "txn_abc123")
 transaction = Paddle::Transaction.retrieve(id: "txn_abc123", extra: "customer")
 
 # Update a transaction
-# https://developer.paddle.com/api-reference/transaction/update-transaction
+# https://developer.paddle.com/api-reference/transactions/update-transaction
 transaction.update(items: [ { price_id: "pri_abc123", quantity: 2 } ])
 # or
 Paddle::Transaction.update(id: "txn_abc123", items: [ { price_id: "pri_abc123", quantity: 2 } ])
 
 # Preview a transaction
-# https://developer.paddle.com/api-reference/transaction/preview-transaction
+# https://developer.paddle.com/api-reference/transactions/preview-transaction
 Paddle::Transaction.preview(items: [ { price_id: "pri_123abc", quantity: 5 } ])
 
 # Get a PDF invoice for a transaction
 # disposition defaults to "attachment"
 # Returns a raw URL. This URL is not permanent and will expire.
-# https://developer.paddle.com/api-reference/transaction/get-invoice-pdf
+# https://developer.paddle.com/api-reference/transactions/get-invoice-pdf
 Paddle::Transaction.invoice(id: "txn_abc123", disposition: "inline")
 #=> https://paddle-sandbox-invoice...
+
+# Revise customer, business and address details on a billed or completed transaction
+# Only address lines, city and region can be changed, and a transaction can only be revised once.
+# The related customer, business and address records aren't updated
+# https://developer.paddle.com/api-reference/transactions/revise-transaction
+Paddle::Transaction.revise(
+  id: "txn_abc123",
+  customer: { name: "Sam Miller" },
+  business: { tax_identifier: "AB0123456789" },
+  address: { first_line: "3811 Ditmars Blvd" }
+)
 ```
 
 ### Subscriptions
@@ -402,6 +526,11 @@ Paddle::Subscription.get_transaction(id: "sub_abc123")
 # https://developer.paddle.com/api-reference/subscriptions/create-one-time-charge
 Paddle::Subscription.charge(id: "sub_abc123", items: [ { price_id: "pri_123abc", quantity: 2 } ], effective_from: "immediately")
 
+# Preview a one-time charge for a subscription without billing it
+# Returns a Subscription with immediate_transaction and next_transaction previews
+# https://developer.paddle.com/api-reference/subscriptions/preview-subscription-charge
+Paddle::Subscription.charge_preview(id: "sub_abc123", items: [ { price_id: "pri_123abc", quantity: 2 } ], effective_from: "immediately")
+
 # Pause a subscription
 # https://developer.paddle.com/api-reference/subscriptions/pause-subscription
 Paddle::Subscription.pause(id: "sub_abc123")
@@ -421,6 +550,18 @@ Paddle::Subscription.cancel(id: "sub_abc123", effective_from: "immediately")
 # Activate a trialing subscription
 # https://developer.paddle.com/api-reference/subscriptions/activate-subscription
 Paddle::Subscription.activate(id: "sub_abc123")
+
+# List the history of a subscription, newest first
+# Returns a Paddle::Collection of Paddle::SubscriptionHistory
+# https://developer.paddle.com/api-reference/subscription-history/list-subscription-history
+Paddle::Subscription.history(id: "sub_abc123")
+Paddle::Subscription.history(id: "sub_abc123", action: [ "subscription_created", "subscription_canceled" ])
+Paddle::Subscription.history(id: "sub_abc123", source: "customer_portal", actor_type: "customer")
+Paddle::Subscription.history(id: "sub_abc123", "occurred_at[GTE]": "2026-01-01T00:00:00Z")
+
+Paddle::Subscription.history(id: "sub_abc123").auto_paging_each do |entry|
+  puts "#{entry.occurred_at} #{entry.detail.action} by #{entry.actor.type} via #{entry.source}"
+end
 ```
 
 ### Customer Portal Sessions
@@ -432,7 +573,6 @@ Paddle::PortalSession.create customer: "ctm_abc123"
 Paddle::PortalSession.create customer: "ctm_abc123", subscription_ids: ["sub_abc123"]
 ```
 
-
 ### Adjustments
 
 ```ruby
@@ -451,11 +591,38 @@ Paddle::Adjustment.create(
   items: [
     {
       type: "full",
-      item_id: "txnitm_anc123"
+      item_id: "txnitm_abc123"
+    }
+  ]
+)
+
+# Partially refund an item
+# amount is in the lowest denomination of the currency, e.g. "500" is $5.00 for USD
+Paddle::Adjustment.create(
+  action: "refund",
+  transaction_id: "txn_abc123",
+  reason: "Requested by customer",
+  items: [
+    {
+      type: "partial",
+      item_id: "txnitm_abc123",
+      amount: "500"
     }
   ]
 )
 
+# Refund or credit the grand total of a transaction without specifying items
+Paddle::Adjustment.create(
+  action: "refund",
+  transaction_id: "txn_abc123",
+  reason: "Requested by customer",
+  type: "full"
+)
+
+# Refunds are created with a status of "pending_approval" and are reviewed by Paddle
+# before being processed. Listen for the adjustment.updated webhook to know when
+# a refund has been approved or rejected.
+
 # Get a credit note for an adjustment
 # disposition defaults to "attachment"
 # Returns a raw URL. This URL is not permanent and will expire.
@@ -546,9 +713,11 @@ Paddle::Notification.list(status: "failed")
 Paddle::Notification.retrieve(id: "ntf_abc123")
 
 # Replay a notification
-# Attempts to resend a notification
-# (currently not working)
+# Creates a new notification for the same event. Only delivered or failed notifications
+# with an origin of "event" can be replayed. Returns the new notification_id
+# https://developer.paddle.com/api-reference/notifications/replay-notification
 Paddle::Notification.replay(id: "ntf_abc123")
+#=> #<Paddle::Notification notification_id="ntf_abc456">
 
 # List all logs for a notification
 # https://developer.paddle.com/api-reference/notifications/list-notification-logs
@@ -580,9 +749,119 @@ Paddle::Report.create(
 )
 ```
 
+### Metrics
+
+Daily metrics for your account. `from` and `to` are dates, as a string like `"2025-09-01"` or a `Date`.
+`from` is inclusive and `to` is exclusive, and you can query up to 3 years in the past.
+Your API key needs the `metrics.read` permission.
+
+```ruby
+# https://developer.paddle.com/api-reference/metrics/overview
+metric = Paddle::Metric.monthly_recurring_revenue(from: "2025-09-01", to: "2025-09-05")
+#=> #<Paddle::Metric interval="day", currency_code="USD", starts_at=..., ends_at=..., timeseries=[...]>
+
+metric.timeseries.each do |point|
+  puts "#{point.timestamp}: #{point.amount}"
+end
+
+# Amounts are strings in the smallest currency unit, e.g. cents
+Paddle::Metric.monthly_recurring_revenue_change(from: "2025-09-01", to: "2025-09-05") # amount
+Paddle::Metric.revenue(from: "2025-09-01", to: "2025-09-05")                          # amount and count
+Paddle::Metric.refunds(from: "2025-09-01", to: "2025-09-05")                          # amount
+Paddle::Metric.active_subscribers(from: "2025-09-01", to: "2025-09-05")               # count
+Paddle::Metric.chargebacks(from: "2025-09-01", to: "2025-09-05")                      # count
+Paddle::Metric.checkout_conversion(from: "2025-09-01", to: "2025-09-05")              # count, completed_count and rate
+```
+
+#### Explore
+
+Explore lets you run your own queries against your account data. Pick an entity and one or more measures,
+then optionally filter the results and break them down by dimensions. Each combination of dimension values is a
+segment, returned as one entry in `series`.
+
+```ruby
+# List the entities you can query, with their dimensions, measures and allowed intervals
+# https://developer.paddle.com/api-reference/metrics/list-explore-metric-entities
+Paddle::Metric.explore_entities
+Paddle::Metric.explore_entities(entity: "transactions.completed")
+
+# Run a query. from is inclusive and to is exclusive. interval can be day, week or month (the default)
+# https://developer.paddle.com/api-reference/metrics/run-explore-metrics-query
+result = Paddle::Metric.explore(
+  entity: "transactions.completed",
+  from: "2026-05-01",
+  to: "2026-08-01",
+  interval: "month",
+  measures: [ { field: "gross_revenue", agg: "sum" } ],
+  dimensions: [ "product" ],
+  order_by: [ { field: "gross_revenue", dir: "desc" } ],
+  filters: [ { field: "country", operator: "in", value: [ "GB", "US" ] } ]
+)
+#=> Paddle::ExploreResult
+
+result.series.each do |segment|
+  puts segment.dimensions.product
+  segment.timeseries.each { |point| puts "  #{point.timestamp}: #{point.measures.sum_gross_revenue}" }
+end
+
+# Results are paged by segment, 5 per page by default (max 50 using per_page)
+result.has_more?
+result.next_page
+#=> Paddle::ExploreResult
+
+# Iterate over every segment across all pages
+result.auto_paging_each do |segment|
+  puts segment.dimensions.product
+end
+```
+
+### Verifying Webhooks
+
+Paddle signs every webhook it sends with a `Paddle-Signature` header. Verify it before trusting the payload.
+You'll need the endpoint secret key for your notification destination, which is the `endpoint_secret_key` on its
+`Paddle::NotificationSetting`, or in the dashboard under Developer Tools > Notifications.
+
+The payload must be the **raw request body**. If it's parsed or reformatted first, the signature won't match.
+
+```ruby
+# https://developer.paddle.com/webhooks/signature-verification
+class PaddleWebhooksController < ApplicationController
+  skip_forgery_protection
+
+  def create
+    event = Paddle::Webhook.construct_event(
+      payload: request.raw_post,
+      signature: request.headers["Paddle-Signature"],
+      secret: ENV["PADDLE_WEBHOOK_SECRET"]
+    )
+    #=> Paddle::Event
+
+    case event.event_type
+    when "transaction.completed"
+      # event.data.id, event.data.customer_id, ...
+    when "subscription.canceled"
+      # ...
+    end
+
+    head :ok
+  rescue Paddle::Webhook::SignatureVerificationError
+    head :bad_request
+  end
+end
+
+# Or just verify the signature. verify! returns true or raises
+# Paddle::Webhook::SignatureVerificationError, and valid? returns true or false
+Paddle::Webhook.verify!(payload: payload, signature: signature, secret: secret)
+Paddle::Webhook.valid?(payload: payload, signature: signature, secret: secret)
+```
+
+Webhooks are rejected if their timestamp is more than 5 seconds from the current time, to stop old requests being
+replayed. You can change this with `tolerance:` (in seconds), or pass `tolerance: nil` to skip the check, for example
+when testing with a stored webhook.
+
 ### Webhook Simulation Types
 
-Retrieves a list of Simulation Types - https://developer.paddle.com/api-reference/simulation-types/overview
+Retrieves a list of Simulation Types - <https://developer.paddle.com/api-reference/simulation-types/overview>
 
 ```ruby
 Paddle::SimulationType.list
@@ -598,8 +877,8 @@ Paddle::Simulation.list(notification_setting_id: "nftset_abc123")
 
 # Create a simulation
 # https://developer.paddle.com/api-reference/simulations/create-simulation
-Paddle::Simulation.create(notification_setting_id: "ntfset_abc123", name: "Customer Create", type: "customer.completed")
-Paddle::Simulation.create(notification_setting_id: "ntfset_abc123", name: "Subscription Created", type: "subscription_creation")
+Paddle::Simulation.create(setting_id: "ntfset_abc123", name: "Customer Create", type: "customer.completed")
+Paddle::Simulation.create(setting_id: "ntfset_abc123", name: "Subscription Created", type: "subscription_creation")
 
 # Retrieve a simulation
 Paddle::Simulation.retrieve(id: "ntfsim_abc123")
@@ -611,6 +890,7 @@ Paddle::Simulation.update(id: "ntfsim_abc123", status: "archived")
 
 # List all simulation runs
 Paddle::Simulation.runs(id: "ntfsim_abc123")
+Paddle::Simulation.runs(id: "ntfsim_abc123", per_page: 10, include: "events")
 
 # Create a simulation run
 # https://developer.paddle.com/api-reference/simulations/create-simulation-run
@@ -620,7 +900,11 @@ Paddle::SimulationRun.create(simulation_id: "ntfsim_abc123")
 Paddle::SimulationRun.retrieve(simulation_id: "ntfsim_abc123", id: "ntfsimrun_abc123")
 
 # List all simulation run events
-Paddle::SimulationRun.events(simulation_id: "ntfsim_abc123", run_id: "ntfsimrun_abc123")
+Paddle::SimulationRun.events(simulation_id: "ntfsim_abc123", id: "ntfsimrun_abc123")
+Paddle::SimulationRun.events(simulation_id: "ntfsim_abc123", id: "ntfsimrun_abc123", per_page: 10)
+
+# Retrieve a simulation run event
+Paddle::SimulationRunEvent.retrieve(simulation_id: "ntfsim_abc123", run_id: "ntfsimrun_abc123", id: "ntfsimevt_abc123")
 
 # Replay a simulation run event
 # https://developer.paddle.com/api-reference/simulations/replay-simulation-run-event
@@ -647,65 +931,9 @@ Paddle::ClientToken.retrieve id: "ctkn_abc123"
 Paddle::ClientToken.update id: "ctkn_abc123", status: "revoked"
 ```
 
-
-## Classic API
-
-For accessing the Paddle Classic API
-
-### Set Client Details
-
-Firstly you'll need to set your Vendor ID, Vendor Auth Code and if you want
-to use the Sandbox API or not.
-
-You can find your vendor details [here for production](https://vendors.paddle.com/authentication),
-or [here for sandbox](https://sandbox-vendors.paddle.com/authentication)
-
-```ruby
-@client = Paddle::Classic::Client.new(
-  vendor_id: "",
-  vendor_auth_code: "",
-  # Use the sandbox version of the API
-  sandbox: true
-)
-```
-
-### Plans
-
-```ruby
-# Retrieves a list of Plans
-@client.plans.list
-```
-
-### Subscription Users
-
-```ruby
-# List all users subscribed to any plan
-@client.users.list
-@client.users.list(subscription_id: "abc123")
-@client.users.list(plan_id: "abc123")
-@client.users.list(state: "active")
-@client.users.list(state: "deleted")
-
-# Update a user's subscription
-# https://developer.paddle.com/api-reference/e3872343dfbba-update-user
-@client.users.update(subscription_id: "abc123")
-
-# Pause a user's subscription
-@client.users.pause(subscription_id: "abc123")
-
-# Unpause a user's subscription
-@client.users.unpause(subscription_id: "abc123")
-
-# Update the Postcode/ZIP Code of a user's subscription
-@client.users.update_postcode(subscription_id: "abc123", postcode: "123abc")
-
-# Cancel a user's subscription
-@client.users.cancel(subscription_id: "abc123")
-```
-
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/deanpcmad/paddle.
+Bug reports and pull requests are welcome on GitHub at <https://github.com/d34ndev/paddle>.
 
 ## License
 

data/lib/paddle/classic/client.rb

@@ -71,10 +71,10 @@ module Paddle
       def connection
         @connection ||= Faraday.new(url) do |conn|
           conn.headers = {
-            "User-Agent" => "paddle/v#{VERSION} (github.com/deanpcmad/paddle)"
+            "User-Agent" => "paddle/v#{VERSION} (github.com/d34ndev/paddle)"
           }
 
-          conn.request :json
+          conn.request :url_encoded
 
           conn.response :json, content_type: "application/json"