async-stripe

CI async-stripe on crates.io async-stripe on docs.rs

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/.

API Version

The latest supported version of the Stripe API is 2020-08-27. 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.

Install

async-stripe is compatible with the async-std and tokio runtimes and the native-tls and rustls backends. When adding the dependency, you much select a runtime feature.

toml [dependencies] async-stripe = { version = "0.13.0-rc3", features = ["runtime-async-std-surf"] }

Feature Flags

Runtimes

API Features

Additionally, since this is a large library, it is possible to conditionally enable features as required to reduce compile times and final binary size. Refer to the Stripe API docs to determine which APIs are included as part of each feature flag.

```toml

Example: Core-only (enough to create a Charge or Card or Customer)

async-stripe = { version = "*", default-features = false, features = ["runtime-async-std-surf"] }

Example: Support for "Subscriptions" and "Invoices"

async-stripe = { version = "*", default-features = false, features = ["runtime-async-std-surf", "billing"] } ```

Getting Started

```rust /* Create a Stripe Client */

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

/* Create a Stripe Charge */

let token = "TOKENFROMCHECKOUT".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, .. }

/* List Stripe Charges */

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

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.

Using Custom Connect accounts

This crate supports impersonating a custom connect account. To impersonate the account get a new Client and pass in the account id.

```rust let mut headers = stripe::Headers::default(); headers.stripeaccount = Some("acctABC".tostring()); headers.clientid = Some("caXYZ".tostring()); 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 { .. }] } ```

MSRV

We currently have 1.49.0 pinned in CI, so any version of rustc newer than that should work. If this is not the case, please open an issue.

Contributing

See CONTRIBUTING.md for information on contributing to async-stripe.

License

This project started as a fork of stripe-rs. We would not be here without them! :)

Licensed under either of

at your option.