Rust API bindings for the Stripe v1 HTTP API.

This is compatible with all currently supported versions of Stripe's client-side libraries including https://js.stripe.com/v2/ and https://js.stripe.com/v3/.

The latest supported version of the Stripe API is w2020-03-02. Set the corresponding crate version depending on which version of the Stripe API you are pinned to. If you don't see the specific version you are on, prefer the next available version.

• 0.13.* - stripe version 2020-03-02 (not yet published)
• 0.12.* - stripe version 2019-09-09

Add this to your Cargo.toml:

[dependencies]
stripe-rust = "0.13.*"

To see how the library is used, look through the examples folder.

To get started, we need to create a client:

  let client = stripe::Client::new("sk_test_YOUR_STRIPE_SECRET");

Then we can begin making requests as we'd like. Most Stripe requests accept many optional parameters, so we usually get the ::default() params and then set the ones we want from there.

Most requests for creating or updating a Stripe object use the same Rust struct, so you may frequently need to refer to the official API docs to determine which fields are required for either request.

  /* Creating a Stripe Charge */

  let token = "TOKEN_FROM_CHECKOUT".parse().expect("token to be valid");
  let mut params = stripe::CreateCharge::new();

  // NOTE: Stripe represents currency in the lowest denominations (e.g. cents)
  params.amount = Some(1095); // e.g. $10.95
  params.source = Some(stripe::ChargeSourceParams::Token(token));

  // Example: Override currency to be in Canadian Dollars
  params.currency = Some(stripe::Currency::CAD);

  let charge = stripe::Charge::create(&client, params).unwrap();
  println!("{:?}", charge); // =>  Charge { id: "ch_12345", amount: 1095, .. }

  /* Listing Stripe Charges */

  let params = stripe::ListCharges::new();
  let charges = stripe::Charge::list(&client, params).unwrap();
  println!("{:?}", charges); // =>  List { data: [Charge { id: "ch_12345", .. }] }

This crate supports impersonating a custom connect account.

To impersonate the account get a new Client and pass in the account id.

  let mut headers = stripe::Headers::default();
  headers.stripe_account = Some("acct_ABC".to_string());
  headers.client_id = Some("ca_XYZ".to_string());
  let client = client.with_headers(headers);

  // Then, all requests can be made normally
  let params = stripe::CustomerListParams::default();
  let customers = stripe::Customer::list(&client, params).unwrap();
  println!("{:?}", customers); // =>  List { data: [Customer { .. }] }

By default the full stripe api is enabled.

To reduce code size, disable default features and enable just the APIs you use:

# Example: Core-only (enough to create a `Charge` or `Card` or `Customer`)
stripe-rust = { version = "*", default-features = false, features = ["default-tls"] }

# Example: Support for "Subscriptions" and "Invoices"
stripe-rust = { version = "*", default-features = false, features = ["default-tls", "billing"] }

Refer to the Stripe API docs to determine which APIs are included as part of each feature flag.

This crate depends on tokio=1. Users of the stripe-rs async client will need all of their dependencies to be compatible with the >1.0 release of tokio. The actix framework is one notable dependency that hasn't released a stable version compatible with tokio 1.0 yet, so you will have to use one of their beta releases to make Stripe calls in an actix handler.

Other libraries you depend on may also bring an outdated async runtime. You can track these down with cargo tree and search crates.io to find suitable updates:

cargo tree | grep "tokio v0"

This library is (mostly) authored via code generation by parsing the OpenAPI specification for Stripe.

To update the generated code, use the included scripts:

# Generate files into the ./openapi/out directort (working directory must be project root)
> ./openapi/build

# Copy reviewed files to ./src/resources
> ./openapi/commit