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:
- Easy configuration path for fast setup and use.
- Helpers for pagination.
- Built-in mechanisms for the serialization of parameters according to the expectations of Stripe's API.
See the Ruby API docs.
See video demonstrations covering how to use the library.
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 stripeIf you want to build the gem from source:
gem build stripe.gemspec- Ruby 2.3+.
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. Set Stripe.api_key to its
value:
require 'stripe'
Stripe.api_key = 'sk_test_...'
# list customers
Stripe::Customer.list()
# retrieve single customer
Stripe::Customer.retrieve('cus_123456789')For apps that need to use multiple keys during the lifetime of a process, like one that uses Stripe Connect, it's also possible to set a per-request key and/or account:
require "stripe"
Stripe::Customer.list(
{},
{
api_key: 'sk_test_...',
stripe_account: 'acct_...',
stripe_version: '2018-02-28',
}
)
Stripe::Customer.retrieve(
'cus_123456789',
{
api_key: 'sk_test_...',
stripe_account: 'acct_...',
stripe_version: '2018-02-28',
}
)
Stripe::Customer.retrieve(
{
id: 'cus_123456789',
expand: %w(balance_transaction)
},
{
stripe_version: '2018-02-28',
api_key: 'sk_test_...',
}
)
Stripe::Customer.capture(
'cus_123456789',
{},
{
stripe_version: '2018-02-28',
api_key: 'sk_test_...',
}
)Keep in mind that there are different method signatures depending on the action:
- When operating on a collection (e.g.
.list,.create) the method signature ismethod(params, opts). - When operating on resource (e.g.
.capture,.update) the method signature ismethod(id, params, opts). - One exception is that
retrieve, despite being an operation on a resource, has the signatureretrieve(id, opts). In addition, it will accept a Hash for theidparam but will extract theidkey out and use the others as options.
Both indexer and accessors can be used to retrieve values of resource properties.
customer = Stripe::Customer.retrieve('cus_123456789')
puts customer['id']
puts customer.idNOTE: If the resource property is not defined, the accessors will raise an exception, while the indexer will return nil.
customer = Stripe::Customer.retrieve('cus_123456789')
puts customer['unknown'] # nil
puts customer.unknown # raises NoMethodErrorGet access to response objects by using the last_response property of the returned resource:
customer = Stripe::Customer.retrieve('cus_123456789')
print(customer.last_response.http_status) # to retrieve status code
print(customer.last_response.http_headers) # to retrieve headersA 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 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 = 2Various errors can trigger a retry, like a connection error or a timeout, and
also certain API responses like HTTP status 409 Conflict.
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_LOGto the valuedebugorinfo:$ 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.
Invoked 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 torequest_endinvocations. 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)
Invoked 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, ornilin 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 inrequest_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)
endIf 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 = falseStripe has features in the beta phase that can be accessed via the beta version of this package.
We would love for you to try these and share feedback with us before these features reach the stable phase.
To install a beta version use gem install with the exact version you'd like to use:
gem install stripe -v 7.1.0.pre.beta.2Note There can be breaking changes between beta versions. Therefore we recommend pinning the package version to a specific beta 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 beta version.
We highly recommend keeping an eye on when the beta feature you are interested in goes from beta to stable so that you can move from using a beta version of the SDK to the stable version.
If your beta feature requires a Stripe-Version header to be sent, set the Stripe.api_version field using Stripe.add_beta_version:
Stripe.add_beta_version("feature_beta", "v3")New features and bug fixes are released on the latest major version of the Stripe Ruby library. If you are on an older major version, we recommend that you upgrade to the latest in order to use the new features and bug fixes including those for security vulnerabilities. Older major versions of the package will continue to be available for use, but will not be receiving any updates.
The test suite depends on stripe-mock, so make sure to fetch and run it from a background terminal (stripe-mock's README also contains instructions for installing via Homebrew and other methods):
go get -u github.com/stripe/stripe-mock
stripe-mockRun all tests:
bundle exec rake testRun a single test suite:
bundle exec ruby -Ilib/ test/stripe/util_test.rbRun a single test:
bundle exec ruby -Ilib/ test/stripe/util_test.rb -n /should.convert.names.to.symbols/Run the linter:
bundle exec rake rubocopUpdate bundled CA certificates from the Mozilla cURL release:
bundle exec rake update_certsUpdate the bundled stripe-mock by editing the version number found in
.travis.yml.
![stripe-openapi[bot] avatar](https://avatars.githubusercontent.com/in/200680?v=4 "stripe-openapi[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent