Ruby library for the Stripe API.
[!TIP] Want to chat live with Stripe engineers? Join us on our Discord server.
The Stripe Ruby library provides convenient access to the Stripe API from applications written in the Ruby language. It includes a pre-defined set of classes for API resources that initialize themselves dynamically from API responses which makes it compatible with a wide range of versions of the Stripe API.
The library also provides other features. For example:
See the Ruby API docs.
You don't need this source code unless you want to modify the gem. If you just want to use the package, just run:
gem install stripe
If you want to build the gem from source:
gem build stripe.gemspec
Per our Language Version Support Policy, we currently support Ruby 2.7+.
Support for Ruby 2.7 is deprecated and will be removed in upcoming major versions. Read more and see the full schedule in the docs: https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy
If you are installing via bundler, you should be sure to use the https rubygems source in your Gemfile, as any gems fetched over http could potentially be compromised in transit and alter the code of gems fetched securely over https:
source 'https://rubygems.org'
gem 'rails'
gem 'stripe'
The library needs to be configured with your account's secret key which is available in your [Stripe Dashboard][api-keys]. Initialize a new client with your API key:
require 'stripe'
client = Stripe::StripeClient.new("sk_test_...")
# list customers
customers = client.v1.customers.list()
# retrieve single customer
customer = client.v1.customers.retrieve('cus_123456789')
For apps that need to use multiple keys during the lifetime of a process, like one that uses [Stripe Connect][connect], it's also possible to set a per-request key and/or account:
require "stripe"
client = Stripe::StripeClient.new("sk_test_...")
client.v1.customers.list(
{},
{
api_key: 'sk_test_...',
stripe_account: 'acct_...',
stripe_version: '2018-02-28',
}
)
We introduced the StripeClient class in v13 of the Ruby SDK. The legacy pattern used prior to that version is still available to use but will be marked as deprecated soon. Review the migration guide to use StripeClient to move from the legacy pattern.
Once the legacy pattern is deprecated, new API endpoints will only be accessible in the StripeClient. While there are no current plans to remove the legacy pattern for existing API endpoints, this may change in the future.
Both indexer and accessors can be used to retrieve values of resource properties.
customer = client.v1.customers.retrieve('cus_123456789')
puts customer['id']
puts customer.id
NOTE: If the resource property is not defined, the accessors will raise an exception, while the indexer will return nil.
customer = client.v1.customers.retrieve('cus_123456789')
puts customer['unknown'] # nil
puts customer.unknown # raises NoMethodError
Get access to response objects by using the last_response property of the returned resource:
customer = client.v1.customers.retrieve('cus_123456789')
print(customer.last_response.http_status) # to retrieve status code
print(customer.last_response.http_headers) # to retrieve headers
If you are accessing a response field with custom hashes provided by you, such as Customer.metadata,
please access your fields with the [] accessor.
A proxy can be configured with Stripe.proxy:
Stripe.proxy = 'https://user:[email protected]:1234'
By default, the library will use the API version pinned to the account making a request. This can be overridden with this global option:
Stripe.api_version = '2018-02-28'
See [versioning in the API reference][versioning] for more information.
By default, the library will use its own internal bundle of known CA certificates, but it's possible to configure your own:
Stripe.ca_bundle_path = 'path/to/ca/bundle'
You can enable automatic retries on requests that fail due to a transient problem by configuring the maximum number of retries:
Stripe.max_network_retries = 2
Various errors can trigger a retry, like a connection error or a timeout, and
also certain API responses like HTTP status 409 Conflict.
[Idempotency keys][idempotency-keys] are added to requests to guarantee that retries are safe.
Open, read and write timeouts are configurable:
Stripe.open_timeout = 30 # in seconds
Stripe.read_timeout = 80
Stripe.write_timeout = 30 # only supported on Ruby 2.6+
Please take care to set conservative read timeouts. Some API requests can take some time, and a short timeout increases the likelihood of a problem within our servers.
The library can be configured to emit logging that will give you better insight
into what it's doing. The info logging level is usually most appropriate for
production use, but debug is also available for more verbosity.
There are a few options for enabling it:
Set the environment variable STRIPE_LOG to the value debug or info:
$ export STRIPE_LOG=info
Set Stripe.log_level:
Stripe.log_level = Stripe::LEVEL_INFO
The library has various hooks that user code can tie into by passing a block to
Stripe::Instrumentation.subscribe to be notified about specific events.
request_beginInvoked when an HTTP request starts. Receives RequestBeginEvent with the
following properties:
method: HTTP method. (Symbol)path: Request path. (String)user_data: A hash on which users can set arbitrary data, and which will be
passed through to request_end invocations. This could be used, for example,
to assign unique IDs to each request, and it'd work even if many requests are
running in parallel. All subscribers share the same object for any particular
request, so they must be careful to use unique keys that will not conflict
with other subscribers. (Hash)request_endInvoked when an HTTP request finishes, regardless of whether it terminated with
a success or error. Receives RequestEndEvent with the following properties:
duration: Request duration in seconds. (Float)http_status: HTTP response code (Integer) if available, or nil in case
of a lower level network error.method: HTTP method. (Symbol)num_retries: The number of retries. (Integer)path: Request path. (String)user_data: A hash on which users may have set arbitrary data in
request_begin. See above for more information. (Hash)request_id: HTTP request identifier. (String)response_header: The response headers. (Hash)response_body = The response body. (String)request_header = The request headers. (Hash)request_body = The request body. (String)For example:
Stripe::Instrumentation.subscribe(:request_end) do |request_event|
# Filter out high-cardinality ids from `path`
path_parts = request_event.path.split("/").drop(2)
resource = path_parts.map { |part| part.match?(/\A[a-z_]+\z/) ? part : ":id" }.join("/")
tags = {
method: request_event.method,
resource: resource,
code: request_event.http_status,
retries: request_event.num_retries
}
StatsD.distribution('stripe_request', request_event.duration, tags: tags)
end
In some cases, you might encounter parameters on an API request or fields on an API response that aren’t available in the SDKs. This might happen when they’re undocumented or when they’re in preview and you aren’t using a preview SDK. See undocumented params and properties to send those parameters or access those fields.
If you're writing a plugin that uses the library, we'd appreciate it if you
identified using #set_app_info:
Stripe.set_app_info('MyAwesomePlugin', version: '1.2.34', url: 'https://myawesomeplugin.info')
This information is passed along when the library makes calls to the Stripe API.
By default, the library sends telemetry to Stripe regarding request latency and feature usage. These numbers help Stripe improve the overall latency of its API for all users, and improve popular features.
You can disable this behavior if you prefer:
Stripe.enable_telemetry = false
In v14.0.0 and newer, the library provides RBI static type annotations. See the wiki for an detailed guide.
Please note that these types are available only for static analysis and we only support RBIs at the moment. Please report an issue if you find discrepancies or have issues using types.
The RBIs can be found in the rbi/stripe/ directory, and to decrease Tapioca loading time we pack the gem with the
combined RBI at rbi/stripe.rbi.
We release type changes in minor releases. While stripe-ruby follows semantic versioning, our semantic
versions describe the runtime behavior of the library alone. Our type annotations are not reflected in the
semantic version. That is, upgrading to a new minor version of stripe-ruby might result in your type checker
producing a type error that it didn't before. You can use ~> x.x or x.x.x constrain the version
of stripe-ruby in your Gemfile to a certain version or range of stripe-ruby.
The types describe the Stripe API version
that was the latest at the time of release. This is the version that your library sends
by default. If you are overriding Stripe.api_version / stripe_version on the StripeClient,
or using a webhook endpoint tied to an older version, be aware that the data
you see at runtime may not match the types.
Stripe has features in the public preview phase that can be accessed via versions of this package that have the -beta.X suffix like 11.2.0-beta.2.
We would love for you to try these as we incrementally release new features and improve them based on your feedback.
To install, pick the latest version with the beta suffix by reviewing the releases page and use it in the gem install command:
gem install stripe -v <replace-with-the-version-of-your-choice>
Note There can be breaking changes between two versions of the public preview SDKs without a bump in the major version. Therefore we recommend pinning the package version to a specific version in your Gemfile. This way you can install the same version each time without breaking changes unless you are intentionally looking for the latest version of the public preview SDK.
We highly recommend keep
No open issues yet, or sync has not completed.