pub struct Client { /* private fields */ }
Implementations
sourceimpl Client
impl Client
sourcepub fn new(secret_key: impl Into<String>) -> Self
pub fn new(secret_key: impl Into<String>) -> Self
Create a new account with the given secret key.
Examples found in repository?
13 14 15 16 17 18 19 20 21 22 23 24 25 26
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key).with_strategy(RequestStrategy::idempotent_with_uuid());
let first_page =
Customer::list(&client, &ListCustomers { limit: Some(1), ..Default::default() })
.await
.unwrap();
println!(
"first page of customers: {:#?}",
first_page.data.iter().map(|c| c.name.as_ref().unwrap()).collect::<Vec<_>>()
);
}
More examples
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key);
let account = Account::create(
&client,
CreateAccount {
type_: Some(AccountType::Express),
capabilities: Some(CreateAccountCapabilities {
card_payments: Some(CreateAccountCapabilitiesCardPayments {
requested: Some(true),
}),
transfers: Some(CreateAccountCapabilitiesTransfers { requested: Some(true) }),
..Default::default()
}),
..Default::default()
},
)
.await
.unwrap();
let link = AccountLink::create(
&client,
CreateAccountLink {
account: account.id.clone(),
type_: AccountLinkType::AccountOnboarding,
collect: None,
expand: &[],
refresh_url: Some("https://test.com/refresh"),
return_url: Some("https://test.com/return"),
},
)
.await
.unwrap();
println!("created a stripe connect link at {}", link.url);
}
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key);
// create a new example project
let product = {
let mut create_product = CreateProduct::new("T-Shirt");
create_product.metadata =
Some([("async-stripe".to_string(), "true".to_string())].iter().cloned().collect());
Product::create(&client, create_product).await.unwrap()
};
// and add a price for it in USD
let price = {
let mut create_price = CreatePrice::new(Currency::USD);
create_price.product = Some(IdOrCreate::Id(&product.id));
create_price.metadata =
Some([("async-stripe".to_string(), "true".to_string())].iter().cloned().collect());
create_price.unit_amount = Some(1000);
create_price.expand = &["product"];
Price::create(&client, create_price).await.unwrap()
};
println!(
"created a product {:?} at price {} {}",
product.name.unwrap(),
price.unit_amount.unwrap() / 100,
price.currency.unwrap()
);
let payment_link = PaymentLink::create(
&client,
CreatePaymentLink::new(vec![CreatePaymentLinkLineItems {
quantity: 3,
price: price.id.to_string(),
..Default::default()
}]),
)
.await
.unwrap();
println!("created a payment link {}", payment_link.url);
}
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key);
let customer = Customer::create(
&client,
CreateCustomer {
name: Some("Alexander Lyon"),
email: Some("test@async-stripe.com"),
description: Some(
"A fake customer that is used to illustrate the examples in async-stripe.",
),
metadata: Some(
[("async-stripe".to_string(), "true".to_string())].iter().cloned().collect(),
),
..Default::default()
},
)
.await
.unwrap();
println!("created a customer at https://dashboard.stripe.com/test/customers/{}", customer.id);
let customer = Customer::create(
&client,
CreateCustomer {
name: Some("Someone Else"),
email: Some("test@async-stripe.com"),
description: Some(
"A fake customer that is used to illustrate the examples in async-stripe.",
),
metadata: Some(
[("async-stripe".to_string(), "true".to_string())].iter().cloned().collect(),
),
..Default::default()
},
)
.await
.unwrap();
println!("created a customer at https://dashboard.stripe.com/test/customers/{}", customer.id);
let params = ListCustomers { ..Default::default() };
let paginator = Customer::list(&client, ¶ms).await.unwrap().paginate(params);
let mut stream = paginator.stream(&client);
// get the next customer
let _next = stream.next().await.unwrap();
// or collect them
let customers = stream.try_collect::<Vec<_>>().await.unwrap();
println!("fetched {} customers: {:?}", customers.len(), customers);
}
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key);
let customer = Customer::create(
&client,
CreateCustomer {
name: Some("Alexander Lyon"),
email: Some("test@async-stripe.com"),
description: Some(
"A fake customer that is used to illustrate the examples in async-stripe.",
),
metadata: Some(
[("async-stripe".to_string(), "true".to_string())].iter().cloned().collect(),
),
..Default::default()
},
)
.await
.unwrap();
println!("created a customer at https://dashboard.stripe.com/test/customers/{}", customer.id);
// create a new exmaple project
let product = {
let mut create_product = CreateProduct::new("T-Shirt");
create_product.metadata =
Some([("async-stripe".to_string(), "true".to_string())].iter().cloned().collect());
Product::create(&client, create_product).await.unwrap()
};
// and add a price for it in USD
let price = {
let mut create_price = CreatePrice::new(Currency::USD);
create_price.product = Some(IdOrCreate::Id(&product.id));
create_price.metadata =
Some([("async-stripe".to_string(), "true".to_string())].iter().cloned().collect());
create_price.unit_amount = Some(1000);
create_price.expand = &["product"];
Price::create(&client, create_price).await.unwrap()
};
println!(
"created a product {:?} at price {} {}",
product.name.unwrap(),
price.unit_amount.unwrap() / 100,
price.currency.unwrap()
);
// finally, create a checkout session for this product / price
let checkout_session = {
let mut params =
CreateCheckoutSession::new("http://test.com/cancel", "http://test.com/success");
params.customer = Some(customer.id);
params.mode = Some(CheckoutSessionMode::Payment);
params.line_items = Some(vec![CreateCheckoutSessionLineItems {
quantity: Some(3),
price: Some(price.id.to_string()),
..Default::default()
}]);
params.expand = &["line_items", "line_items.data.price.product"];
CheckoutSession::create(&client, params).await.unwrap()
};
println!(
"created a {} checkout session for {} {:?} for {} {} at {}",
checkout_session.payment_status,
checkout_session.line_items.data[0].quantity.unwrap(),
match checkout_session.line_items.data[0].price.as_ref().unwrap().product.as_ref().unwrap()
{
Expandable::Object(p) => p.name.as_ref().unwrap(),
_ => panic!("product not found"),
},
checkout_session.amount_subtotal.unwrap() / 100,
checkout_session.line_items.data[0].price.as_ref().unwrap().currency.unwrap(),
checkout_session.url.unwrap()
);
}
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key);
let customer = Customer::create(
&client,
CreateCustomer {
name: Some("Alexander Lyon"),
email: Some("test@async-stripe.com"),
description: Some(
"A fake customer that is used to illustrate the examples in async-stripe.",
),
metadata: Some(
[("async-stripe".to_string(), "true".to_string())].iter().cloned().collect(),
),
..Default::default()
},
)
.await
.unwrap();
println!("created a customer at https://dashboard.stripe.com/test/customers/{}", customer.id);
// we create an intent to pay
let payment_intent = {
let mut create_intent = CreatePaymentIntent::new(1000, Currency::USD);
create_intent.payment_method_types = Some(vec!["card".to_string()]);
create_intent.statement_descriptor = Some("Purchasing a new car");
create_intent.metadata =
Some([("color".to_string(), "red".to_string())].iter().cloned().collect());
PaymentIntent::create(&client, create_intent).await.unwrap()
};
println!(
"created a payment intent at https://dashboard.stripe.com/test/payments/{} with status '{}'",
payment_intent.id, payment_intent.status
);
let payment_method = {
let pm = PaymentMethod::create(
&client,
CreatePaymentMethod {
type_: Some(PaymentMethodTypeFilter::Card),
card: Some(CreatePaymentMethodCardUnion::CardDetailsParams(CardDetailsParams {
number: "4000008260000000".to_string(), // UK visa
exp_year: 2025,
exp_month: 1,
cvc: Some("123".to_string()),
..Default::default()
})),
..Default::default()
},
)
.await
.unwrap();
PaymentMethod::attach(
&client,
&pm.id,
AttachPaymentMethod { customer: customer.id.clone() },
)
.await
.unwrap();
pm
};
println!(
"created a payment method with id {} and attached it to {}",
payment_method.id,
customer.name.unwrap()
);
// lets update the payment intent with their details
let payment_intent = PaymentIntent::update(
&client,
&payment_intent.id,
UpdatePaymentIntent {
payment_method: Some(payment_method.id),
customer: Some(customer.id), // this is not strictly required but good practice to ensure we have the right person
..Default::default()
},
)
.await
.unwrap();
println!("updated payment intent with status '{}'", payment_intent.status);
let payment_intent = PaymentIntent::confirm(
&client,
&payment_intent.id,
PaymentIntentConfirmParams { ..Default::default() },
)
.await
.unwrap();
println!("completed payment intent with status {}", payment_intent.status);
}
sourcepub fn from_url<'a>(
url: impl Into<&'a str>,
secret_key: impl Into<String>
) -> Self
pub fn from_url<'a>(
url: impl Into<&'a str>,
secret_key: impl Into<String>
) -> Self
Create a new account pointed at a specific URL. This is useful for testing.
sourcepub fn with_client_id(self, id: ApplicationId) -> Self
pub fn with_client_id(self, id: ApplicationId) -> Self
Set the client id for the client.
sourcepub fn with_stripe_account(self, id: AccountId) -> Self
pub fn with_stripe_account(self, id: AccountId) -> Self
Set the stripe account for the client.
sourcepub fn with_strategy(self, strategy: RequestStrategy) -> Self
pub fn with_strategy(self, strategy: RequestStrategy) -> Self
Set the request strategy for the client.
Examples found in repository?
13 14 15 16 17 18 19 20 21 22 23 24 25 26
async fn main() {
let secret_key = std::env::var("STRIPE_SECRET_KEY").expect("Missing STRIPE_SECRET_KEY in env");
let client = Client::new(secret_key).with_strategy(RequestStrategy::idempotent_with_uuid());
let first_page =
Customer::list(&client, &ListCustomers { limit: Some(1), ..Default::default() })
.await
.unwrap();
println!(
"first page of customers: {:#?}",
first_page.data.iter().map(|c| c.name.as_ref().unwrap()).collect::<Vec<_>>()
);
}
sourcepub fn with_app_info(
self,
name: String,
version: Option<String>,
url: Option<String>
) -> Self
pub fn with_app_info(
self,
name: String,
version: Option<String>,
url: Option<String>
) -> Self
Set the application info for the client.
It is recommended that applications set this so that stripe is able to undestand usage patterns from your user agent.
sourcepub fn get<T: DeserializeOwned + Send + 'static>(
&self,
path: &str
) -> Response<T>
pub fn get<T: DeserializeOwned + Send + 'static>(
&self,
path: &str
) -> Response<T>
Make a GET
http request with just a path
sourcepub fn get_query<T: DeserializeOwned + Send + 'static, P: Serialize>(
&self,
path: &str,
params: P
) -> Response<T>
pub fn get_query<T: DeserializeOwned + Send + 'static, P: Serialize>(
&self,
path: &str,
params: P
) -> Response<T>
Make a GET
http request with url query parameters
sourcepub fn delete<T: DeserializeOwned + Send + 'static>(
&self,
path: &str
) -> Response<T>
pub fn delete<T: DeserializeOwned + Send + 'static>(
&self,
path: &str
) -> Response<T>
Make a DELETE
http request with just a path
sourcepub fn delete_query<T: DeserializeOwned + Send + 'static, P: Serialize>(
&self,
path: &str,
params: P
) -> Response<T>
pub fn delete_query<T: DeserializeOwned + Send + 'static, P: Serialize>(
&self,
path: &str,
params: P
) -> Response<T>
Make a DELETE
http request with url query parameters
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Client
impl Send for Client
impl Sync for Client
impl Unpin for Client
impl !UnwindSafe for Client
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more