Create fixed-price subscriptions

# Available as a gem
gem install stripe
# Available as a gem
gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

# Install through pip
pip install --upgrade stripe
# Install through pip
pip install --upgrade stripe

# Or find the Stripe package on http://pypi.python.org/pypi/stripe/
# Or find the Stripe package on http://pypi.python.org/pypi/stripe/

# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0

# Install the PHP library via Composer
composer require stripe/stripe-php
# Install the PHP library via Composer
composer require stripe/stripe-php

# Or download the source directly: https://github.com/stripe/stripe-php/releases
# Or download the source directly: https://github.com/stripe/stripe-php/releases

/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"
/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"

<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>
<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>

# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson
# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson

# Install via npm
npm install --save stripe
# Install via npm
npm install --save stripe

# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71

// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)
// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)

# Install via dotnet
dotnet add package Stripe.net
dotnet restore
# Install via dotnet
dotnet add package Stripe.net
dotnet restore

# Or install via NuGet
PM> Install-Package Stripe.net
# Or install via NuGet
PM> Install-Package Stripe.net

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/stripe-webhook' do
  # You can use webhooks to receive information about asynchronous payment events.
  # For more about our webhook events check out https://stripe.com/docs/webhooks.
  webhook_secret = ENV['STRIPE_WEBHOOK_SECRET']
  payload = request.body.read
  if !webhook_secret.empty?    # Retrieve the event by verifying the signature using the raw body and secret if webhook signing is configured.
    sig_header = request.env['HTTP_STRIPE_SIGNATURE']
    event = nil

    begin
      event = Stripe::Webhook.construct_event(
        payload, sig_header, webhook_secret
      )
    rescue JSON::ParserError => e
      # Invalid payload
      status 400
      return
    rescue Stripe::SignatureVerificationError => e
      # Invalid signature
      puts '⚠️  Webhook signature verification failed.'
      status 400
      return
    end
  else
    data = JSON.parse(payload, symbolize_names: true)
    event = Stripe::Event.construct_from(data)
  end
  # Get the type of webhook event sent - used to check the status of PaymentIntents.
  event_type = event['type']
  data = event['data']
  data_object = data['object']

  if event_type == 'invoice.paid'
    # Used to provision services after the trial has ended.
    # The status of the invoice will show up as paid. Store the status in your
    # database to reference when a user accesses your service to avoid hitting rate
    # limits.
    # puts data_object
  end

  if event_type == 'invoice.payment_failed'
    # If the payment fails or the customer does not have a valid payment method,
    # an invoice.payment_failed event is sent, the subscription becomes past_due.
    # Use this webhook to notify your user that their payment has
    # failed and to retrieve new card details.
    # puts data_object
  end

  if event_type == 'customer.subscription.deleted'
    # handle subscription cancelled automatically based
    # upon your subscription settings. Or if the user cancels it.
    # puts data_object
  end

  content_type 'application/json'
  { status: 'success' }.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/stripe-webhook' do
  # You can use webhooks to receive information about asynchronous payment events.
  # For more about our webhook events check out https://stripe.com/docs/webhooks.
  webhook_secret = ENV['STRIPE_WEBHOOK_SECRET']
  payload = request.body.read
  if !webhook_secret.empty?

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/stripe-webhook', methods=['POST'])
def webhook_received():
    # You can use webhooks to receive information about asynchronous payment events.
    # For more about our webhook events check out https://stripe.com/docs/webhooks.
    webhook_secret = os.getenv('STRIPE_WEBHOOK_SECRET')
    request_data = json.loads(request.data)
    if webhook_secret:
        # Retrieve the event by verifying the signature using the raw body and secret if webhook signing is configured.
        signature = request.headers.get('stripe-signature')
        try:
            event = stripe.Webhook.construct_event(
                payload=request.data, sig_header=signature, secret=webhook_secret)
            data = event['data']
        except Exception as e:
            return e
        # Get the type of webhook event sent - used to check the status of PaymentIntents.
        event_type = event['type']
    else:
        data = request_data['data']
        event_type = request_data['type']

    data_object = data['object']

    if event_type == 'invoice.paid':
        # Used to provision services after the trial has ended.
        # The status of the invoice will show up as paid. Store the status in your
        # database to reference when a user accesses your service to avoid hitting rate
        # limits.
        print(data)

    if event_type == 'invoice.payment_failed':
        # If the payment fails or the customer does not have a valid payment method,
        # an invoice.payment_failed event is sent, the subscription becomes past_due.
        # Use this webhook to notify your user that their payment has
        # failed and to retrieve new card details.
        print(data)

    if event_type == 'customer.subscription.deleted':
        # handle subscription cancelled automatically based
        # upon your subscription settings. Or if the user cancels it.
        print(data)

    return jsonify({'status': 'success'})
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/stripe-webhook', methods=['POST'])
def webhook_received():
    # You can use webhooks to receive information about asynchronous payment events.
    # For more about our webhook events check out https://stripe.com/docs/webhooks.
    webhook_secret = os.getenv('STRIPE_WEBHOOK_SECRET')
    request_data = json.loads(request.data)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/stripe-webhook', function(Request $request, Response $response) {
  $logger = $this->get('logger');
  $event = $request->getParsedBody();
  $stripe = $this->stripe;

  // Parse the message body (and check the signature if possible)  $webhookSecret = getenv('STRIPE_WEBHOOK_SECRET');
  if ($webhookSecret) {
    try {
      $event = $stripe->webhooks->constructEvent(
        $request->getBody(),
        $request->getHeaderLine('stripe-signature'),
        $webhookSecret
      );

    } catch (Exception $e) {
      return $response->withJson([ 'error' => $e->getMessage() ])->withStatus(403);
    }
  } else {
    $event = $request->getParsedBody();
  }
  $type = $event['type'];
  $object = $event['data']['object'];

  // Handle the event
  // Review important events for Billing webhooks
  // https://stripe.com/docs/billing/webhooks
  // Remove comment to see the various objects sent for this sample
  switch ($type) {
    case 'invoice.paid':
      // The status of the invoice will show up as paid. Store the status in your
      // database to reference when a user accesses your service to avoid hitting rate
      // limits.
      $logger->info('🔔  Webhook received! ' . $object);
      break;
    case 'invoice.payment_failed':
      // If the payment fails or the customer does not have a valid payment method,
      // an invoice.payment_failed event is sent, the subscription becomes past_due.
      // Use this webhook to notify your user that their payment has
      // failed and to retrieve new card details.
      $logger->info('🔔  Webhook received! ' . $object);
      break;
    case 'customer.subscription.deleted':
      // handle subscription cancelled automatically based
      // upon your subscription settings. Or if the user
      // cancels it.
      $logger->info('🔔  Webhook received! ' . $object);
      break;
    // ... handle other event types
    default:
      // Unhandled event type
  }

  return $response->withJson([ 'status' => 'success' ])->withStatus(200);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/stripe-webhook', function(Request $request, Response $response) {
  $logger = $this->get('logger');
  $event = $request->getParsedBody();
  $stripe = $this->stripe;

  // Parse the message body (and check the signature if possible)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/stripe-webhook",
  (request, response) -> {
    String payload = request.body();
    String sigHeader = request.headers("Stripe-Signature");
    String endpointSecret = dotenv.get("STRIPE_WEBHOOK_SECRET");    Event event = null;

    try {
      event = Webhook.constructEvent(payload, sigHeader, endpointSecret);
    } catch (SignatureVerificationException e) {
      // Invalid signature
      response.status(400);
      return "";
    }

    // Deserialize the nested object inside the event
    EventDataObjectDeserializer dataObjectDeserializer = event.getDataObjectDeserializer();
    StripeObject stripeObject = null;
    if (dataObjectDeserializer.getObject().isPresent()) {
      stripeObject = dataObjectDeserializer.getObject().get();
    } else {
      // Deserialization failed, probably due to an API version mismatch.
      // Refer to the Javadoc documentation on `EventDataObjectDeserializer` for
      // instructions on how to handle this case, or return an error here.
    }

    switch (event.getType()) {
      case "invoice.paid":
        // Used to provision services after the trial has ended.
        // The status of the invoice will show up as paid. Store the status in your
        // database to reference when a user accesses your service to avoid hitting rate
        // limits.
        break;
      case "invoice.payment_failed":
        // If the payment fails or the customer does not have a valid payment method,
        // an invoice.payment_failed event is sent, the subscription becomes past_due.
        // Use this webhook to notify your user that their payment has
        // failed and to retrieve new card details.
        break;
      case "customer.subscription.deleted":
        // handle subscription cancelled automatically based
        // upon your subscription settings. Or if the user
        // cancels it.
        break;
      default:
      // Unhandled event type
    }

    response.status(200);
    return "";
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/stripe-webhook",
  (request, response) -> {
    String payload = request.body();
    String sigHeader = request.headers("Stripe-Signature");
    String endpointSecret = dotenv.get("STRIPE_WEBHOOK_SECRET");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post(
  '/stripe-webhook',
  bodyParser.raw({ type: 'application/json' }),
  async (req, res) => {
    // Retrieve the event by verifying the signature using the raw body and secret.
    let event;
    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        req.headers['stripe-signature'],
        process.env.STRIPE_WEBHOOK_SECRET
      );
    } catch (err) {
      console.log(err);
      console.log(`⚠️  Webhook signature verification failed.`);
      console.log(
        `⚠️  Check the env file and enter the correct webhook secret.`
      );
      return res.sendStatus(400);
    }
    // Extract the object from the event.
    const dataObject = event.data.object;

    // Handle the event
    // Review important events for Billing webhooks
    // https://stripe.com/docs/billing/webhooks
    // Remove comment to see the various objects sent for this sample
    switch (event.type) {
      case 'invoice.paid':
        // Used to provision services after the trial has ended.
        // The status of the invoice will show up as paid. Store the status in your
        // database to reference when a user accesses your service to avoid hitting rate limits.
        break;
      case 'invoice.payment_failed':
        // If the payment fails or the customer does not have a valid payment method,
        //  an invoice.payment_failed event is sent, the subscription becomes past_due.
        // Use this webhook to notify your user that their payment has
        // failed and to retrieve new card details.
        break;
      case 'customer.subscription.deleted':
        if (event.request != null) {
          // handle a subscription cancelled by your request
          // from above.
        } else {
          // handle subscription cancelled automatically based
          // upon your subscription settings.
        }
        break;
      default:
      // Unexpected event type
    }
    res.sendStatus(200);
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post(
  '/stripe-webhook',
  bodyParser.raw({ type: 'application/json' }),
  async (req, res) => {
    // Retrieve the event by verifying the signature using the raw body and secret.
    let event;

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

func handleWebhook(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  b, err := ioutil.ReadAll(r.Body)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    log.Printf("ioutil.ReadAll: %v", err)
    return
  }

  event, err := webhook.ConstructEvent(b, r.Header.Get("Stripe-Signature"), os.Getenv("STRIPE_WEBHOOK_SECRET"))
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    log.Printf("webhook.ConstructEvent: %v", err)
    return
  }

  if event.Type == "invoice.paid" {
    // Used to provision services after the trial has ended.
    // The status of the invoice will show up as paid. Store the status in your
    // database to reference when a user accesses your service to avoid hitting rate
    // limits.
    return
  }

  if event.Type == "invoice.payment_failed" {
    // If the payment fails or the customer does not have a valid payment method,
    // an invoice.payment_failed event is sent, the subscription becomes past_due.
    // Use this webhook to notify your user that their payment has
    // failed and to retrieve new card details.
    return
  }

  if event.Type == "customer.subscription.deleted" {
    // handle subscription cancelled automatically based
    // upon your subscription settings. Or if the user cancels it. {
    return
  }
}
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

func handleWebhook(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  b, err := ioutil.ReadAll(r.Body)
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    log.Printf("ioutil.ReadAll: %v", err)
    return
  }

  event, err := webhook.ConstructEvent(b, r.Header.Get("Stripe-Signature"), os.Getenv("STRIPE_WEBHOOK_SECRET"))
  if err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    log.Printf("webhook.ConstructEvent: %v", err)
    return
  }

  if event.Type == "invoice.paid" {
    // Used to provision services after the trial has ended.
    // The status of the invoice will show up as paid. Store the status in your
    // database to reference when a user accesses your service to avoid hitting rate
    // limits.
    return
  }

  if event.Type == "invoice.payment_failed" {
    // If the payment fails or the customer does not have a valid payment method,
    // an invoice.payment_failed event is sent, the subscription becomes past_due.
    // Use this webhook to notify your user that their payment has
    // failed and to retrieve new card details.
    return
  }

  if event.Type == "customer.subscription.deleted" {
    // handle subscription cancelled automatically based
    // upon your subscription settings. Or if the user cancels it. {
    return
  }
}

[HttpPost("stripe-webhook")]
public async Task<IActionResult> Webhook()
{
    var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
    Event stripeEvent;
    try
    {
        stripeEvent = EventUtility.ConstructEvent(
            json,
            Request.Headers["Stripe-Signature"],
            this.options.Value.WebhookSecret
        );
        Console.WriteLine($"Webhook notification with type: {stripeEvent.Type} found for {stripeEvent.Id}");
    }
    catch (Exception e)
    {
        Console.WriteLine($"Something failed {e}");
        return BadRequest();
    }

    if (stripeEvent.Type == "invoice.paid")
    {
        // Used to provision services after the trial has ended.
        // The status of the invoice will show up as paid. Store the status in your
        // database to reference when a user accesses your service to avoid hitting rate
        // limits.
    }

    if (stripeEvent.Type == "invoice.payment_failed")
    {
        // If the payment fails or the customer does not have a valid payment method,
        // an invoice.payment_failed event is sent, the subscription becomes past_due.
        // Use this webhook to notify your user that their payment has
        // failed and to retrieve new card details.
    }

    if (stripeEvent.Type == "customer.subscription.deleted")
    {
        // handle subscription cancelled automatically based
        // upon your subscription settings. Or if the user cancels it.
    }
    return Ok();
}
[HttpPost("stripe-webhook")]
public async Task<IActionResult> Webhook()
{
    var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
    Event stripeEvent;
    try
    {
        stripeEvent = EventUtility.ConstructEvent(
            json,
            Request.Headers["Stripe-Signature"],
            this.options.Value.WebhookSecret
        );
        Console.WriteLine($"Webhook notification with type: {stripeEvent.Type} found for {stripeEvent.Id}");
    }
    catch (Exception e)
    {
        Console.WriteLine($"Something failed {e}");
        return BadRequest();
    }

    if (stripeEvent.Type == "invoice.paid")
    {
        // Used to provision services after the trial has ended.
        // The status of the invoice will show up as paid. Store the status in your
        // database to reference when a user accesses your service to avoid hitting rate
        // limits.
    }

    if (stripeEvent.Type == "invoice.payment_failed")
    {
        // If the payment fails or the customer does not have a valid payment method,
        // an invoice.payment_failed event is sent, the subscription becomes past_due.
        // Use this webhook to notify your user that their payment has
        // failed and to retrieve new card details.
    }

    if (stripeEvent.Type == "customer.subscription.deleted")
    {
        // handle subscription cancelled automatically based
        // upon your subscription settings. Or if the user cancels it.
    }
    return Ok();
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/create-customer' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  # Create a new customer object
  customer = Stripe::Customer.create(email: data['email'])

  # Recommendation: save the customer.id in your database.

  { 'customer': customer }.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/create-customer' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  # Create a new customer object
  customer = Stripe::Customer.create(email: data['email'])

  # Recommendation: save the customer.id in your database.

  { 'customer': customer }.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/create-customer', methods=['POST'])
def create_customer():
    # Reads application/json and returns a response
    data = json.loads(request.data)
    try:
        # Create a new customer object
        customer = stripe.Customer.create(
            email=data['email']
        )
        # At this point, associate the ID of the Customer object with your
        # own internal representation of a customer, if you have one.

        return jsonify(
            customer=customer,
        )
    except Exception as e:
        return jsonify(error=str(e)), 403
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/create-customer', methods=['POST'])
def create_customer():
    # Reads application/json and returns a response
    data = json.loads(request.data)
    try:
        # Create a new customer object
        customer = stripe.Customer.create(
            email=data['email']
        )
        # At this point, associate the ID of the Customer object with your
        # own internal representation of a customer, if you have one.

        return jsonify(
            customer=customer,
        )
    except Exception as e:
        return jsonify(error=str(e)), 403

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/create-customer', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());

  $stripe = $this->stripe;

  $customer = $stripe->customers->create([
    'email' => $body->email
  ]);

  return $response->withJson(['customer' => $customer]);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/create-customer', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());

  $stripe = $this->stripe;

  $customer = $stripe->customers->create([
    'email' => $body->email
  ]);

  return $response->withJson(['customer' => $customer]);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/create-customer",
  (request, response) -> {
    response.type("application/json");

    CreateCustomerBody postBody = gson.fromJson(
      request.body(),
      CreateCustomerBody.class
    );

    CustomerCreateParams customerParams = CustomerCreateParams
      .builder()
      .setEmail(postBody.getEmail())
      .build();
    // Create a new customer object
    Customer customer = Customer.create(customerParams);

    Map<String, Object> responseData = new HashMap<>();
    responseData.put("customer", customer);

    //we use StripeObject.PRETTY_PRINT_GSON.toJson() so that we get the JSON our client is expecting on the polymorphic
    //parameters that can either be object ids or the object themselves. If we tried to generate the JSON without call this,
    //for example, by calling gson.toJson(responseData) we will see something like "customer":{"id":"cus_XXX"} instead of
    //"customer":"cus_XXX".
    //If you only need to return 1 object, you can use the built in serializers, i.e. Subscription.retrieve("sub_XXX").toJson()
    return StripeObject.PRETTY_PRINT_GSON.toJson(responseData);
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/create-customer",
  (request, response) -> {
    response.type("application/json");

    CreateCustomerBody postBody = gson.fromJson(
      request.body(),
      CreateCustomerBody.class
    );

    CustomerCreateParams customerParams = CustomerCreateParams
      .builder()
      .setEmail(postBody.getEmail())
      .build();
    // Create a new customer object
    Customer customer = Customer.create(customerParams);

    Map<String, Object> responseData = new HashMap<>();
    responseData.put("customer", customer);

    //we use StripeObject.PRETTY_PRINT_GSON.toJson() so that we get the JSON our client is expecting on the polymorphic
    //parameters that can either be object ids or the object themselves. If we tried to generate the JSON without call this,
    //for example, by calling gson.toJson(responseData) we will see something like "customer":{"id":"cus_XXX"} instead of
    //"customer":"cus_XXX".
    //If you only need to return 1 object, you can use the built in serializers, i.e. Subscription.retrieve("sub_XXX").toJson()
    return StripeObject.PRETTY_PRINT_GSON.toJson(responseData);
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/create-customer', async (req, res) => {
  // Create a new customer object
  const customer = await stripe.customers.create({
    email: req.body.email,
  });

  // save the customer.id as stripeCustomerId
  // in your database.

  res.send({ customer });
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/create-customer', async (req, res) => {
  // Create a new customer object
  const customer = await stripe.customers.create({
    email: req.body.email,
  });

  // save the customer.id as stripeCustomerId
  // in your database.

  res.send({ customer });
});

func handleCreateCustomer(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    Email string `json:"email"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  params := &stripe.CustomerParams{
    Email: stripe.String(req.Email),
  }
  c, err := customer.New(params)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.New: %v", err)
    return
  }
  writeJSON(w, struct {
    Customer *stripe.Customer `json:"customer"`
  }{
    Customer: c,
  })
}
func handleCreateCustomer(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    Email string `json:"email"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  params := &stripe.CustomerParams{
    Email: stripe.String(req.Email),
  }
  c, err := customer.New(params)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.New: %v", err)
    return
  }
  writeJSON(w, struct {
    Customer *stripe.Customer `json:"customer"`
  }{
    Customer: c,
  })
}

using Newtonsoft.Json;

public class CreateCustomerRequest
{
    [JsonProperty("email")]
    public string Email { get; set; }
}
using Newtonsoft.Json;

public class CreateCustomerRequest
{
    [JsonProperty("email")]
    public string Email { get; set; }
}

using Newtonsoft.Json;
using Stripe;

public class CreateCustomerResponse
{
    [JsonProperty("customer")]
    public Customer Customer { get; set; }
}
using Newtonsoft.Json;
using Stripe;

public class CreateCustomerResponse
{
    [JsonProperty("customer")]
    public Customer Customer { get; set; }
}

[HttpPost("create-customer")]
public ActionResult<CreateCustomerResponse> CreateCustomer([FromBody] CreateCustomerRequest req)
{
    var options = new CustomerCreateOptions
    {
        Email = req.Email,
    };
    var service = new CustomerService();
    var customer = service.Create(options);
    return new CreateCustomerResponse
    {
        Customer = customer,
    };
}
[HttpPost("create-customer")]
public ActionResult<CreateCustomerResponse> CreateCustomer([FromBody] CreateCustomerRequest req)
{
    var options = new CustomerCreateOptions
    {
        Email = req.Email,
    };
    var service = new CustomerService();
    var customer = service.Create(options);
    return new CreateCustomerResponse
    {
        Customer = customer,
    };
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/create-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  begin
    Stripe::PaymentMethod.attach(
      data['paymentMethodId'],
      { customer: data['customerId'] }
    )
  rescue Stripe::CardError => e
    halt 200,
         { 'Content-Type' => 'application/json' },
         { 'error': { message: e.error.message } }.to_json
  end

  # Set the default payment method on the customer
  Stripe::Customer.update(
    data['customerId'],
    invoice_settings: { default_payment_method: data['paymentMethodId'] }
  )

  # Create the subscription
  subscription =
    Stripe::Subscription.create(
      customer: data['customerId'],
      items: [{ price: 'price_HGd7M3DV3IMXkC' }],
      expand: %w[latest_invoice.payment_intent]
    )

  subscription.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/create-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  begin
    Stripe::PaymentMethod.attach(
      data['paymentMethodId'],
      { customer: data['customerId'] }
    )
  rescue Stripe::CardError => e
    halt 200,
         { 'Content-Type' => 'application/json' },
         { 'error': { message: e.error.message } }.to_json
  end

  # Set the default payment method on the customer
  Stripe::Customer.update(
    data['customerId'],
    invoice_settings: { default_payment_method: data['paymentMethodId'] }
  )

  # Create the subscription
  subscription =
    Stripe::Subscription.create(
      customer: data['customerId'],
      items: [{ price: 'price_HGd7M3DV3IMXkC' }],
      expand: %w[latest_invoice.payment_intent]
    )

  subscription.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/create-subscription', methods=['POST'])
def createSubscription():
    data = json.loads(request.data)
    try:
        # Attach the payment method to the customer
        stripe.PaymentMethod.attach(
            data['paymentMethodId'],
            customer=data['customerId'],
        )
        # Set the default payment method on the customer
        stripe.Customer.modify(
            data['customerId'],
            invoice_settings={
                'default_payment_method': data['paymentMethodId'],
            },
        )

        # Create the subscription
        subscription = stripe.Subscription.create(
            customer=data['customerId'],
            items=[
                {
                    'price': 'price_HGd7M3DV3IMXkC'
                }
            ],
            expand=['latest_invoice.payment_intent'],
        )
        return jsonify(subscription)
    except Exception as e:
        return jsonify(error={'message': str(e)}), 200
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/create-subscription', methods=['POST'])
def createSubscription():
    data = json.loads(request.data)
    try:
        # Attach the payment method to the customer
        stripe.PaymentMethod.attach(
            data['paymentMethodId'],
            customer=data['customerId'],
        )
        # Set the default payment method on the customer
        stripe.Customer.modify(
            data['customerId'],
            invoice_settings={
                'default_payment_method': data['paymentMethodId'],
            },
        )

        # Create the subscription
        subscription = stripe.Subscription.create(
            customer=data['customerId'],
            items=[
                {
                    'price': 'price_HGd7M3DV3IMXkC'
                }
            ],
            expand=['latest_invoice.payment_intent'],
        )
        return jsonify(subscription)
    except Exception as e:
        return jsonify(error={'message': str(e)}), 200

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/create-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  try {
    $payment_method = $stripe->paymentMethods->retrieve(
      $body->paymentMethodId
    );
    $payment_method->attach([
      'customer' => $body->customerId,
    ]);
  } catch (Exception $e) {
    return $response->withJson($e->jsonBody);
  }


  // Set the default payment method on the customer
  $stripe->customers->update($body->customerId, [
    'invoice_settings' => [
      'default_payment_method' => $body->paymentMethodId
    ]
  ]);

  // Create the subscription
  $subscription = $stripe->subscriptions->create([
    'customer' => $body->customerId,
    'items' => [
      [
        'price' => 'price_HGd7M3DV3IMXkC',
      ],
    ],
    'expand' => ['latest_invoice.payment_intent'],
  ]);

  return $response->withJson($subscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/create-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  try {
    $payment_method = $stripe->paymentMethods->retrieve(
      $body->paymentMethodId
    );
    $payment_method->attach([
      'customer' => $body->customerId,
    ]);
  } catch (Exception $e) {
    return $response->withJson($e->jsonBody);
  }


  // Set the default payment method on the customer
  $stripe->customers->update($body->customerId, [
    'invoice_settings' => [
      'default_payment_method' => $body->paymentMethodId
    ]
  ]);

  // Create the subscription
  $subscription = $stripe->subscriptions->create([
    'customer' => $body->customerId,
    'items' => [
      [
        'price' => 'price_HGd7M3DV3IMXkC',
      ],
    ],
    'expand' => ['latest_invoice.payment_intent'],
  ]);

  return $response->withJson($subscription);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/create-subscription",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    CreateSubscriptionBody postBody = gson.fromJson(
      request.body(),
      CreateSubscriptionBody.class
    );
    Customer customer = Customer.retrieve(postBody.getCustomerId());

    try {
      // Set the default payment method on the customer
      PaymentMethod pm = PaymentMethod.retrieve(
        postBody.getPaymentMethodId()
      );
      pm.attach(
        PaymentMethodAttachParams
          .builder()
          .setCustomer(customer.getId())
          .build()
      );
    } catch (CardException e) {
      // Since it's a decline, CardException will be caught
      Map<String, String> responseErrorMessage = new HashMap<>();
      responseErrorMessage.put("message", e.getLocalizedMessage());
      Map<String, Object> responseError = new HashMap<>();
      responseError.put("error", responseErrorMessage);

      return gson.toJson(responseError);
    }

    CustomerUpdateParams customerUpdateParams = CustomerUpdateParams
      .builder()
      .setInvoiceSettings(
        CustomerUpdateParams
          .InvoiceSettings.builder()
          .setDefaultPaymentMethod(postBody.getPaymentMethodId())
          .build()
      )
      .build();

    customer.update(customerUpdateParams);

    // Create the subscription
    SubscriptionCreateParams subCreateParams = SubscriptionCreateParams
      .builder()
      .addItem(
        SubscriptionCreateParams
          .Item.builder()
          .setPrice("price_HGd7M3DV3IMXkC")
          .build()
      )
      .setCustomer(customer.getId())
      .addAllExpand(Arrays.asList("latest_invoice.payment_intent"))
      .build();

    Subscription subscription = Subscription.create(subCreateParams);

    return subscription.toJson();
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/create-subscription",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    CreateSubscriptionBody postBody = gson.fromJson(
      request.body(),
      CreateSubscriptionBody.class
    );
    Customer customer = Customer.retrieve(postBody.getCustomerId());

    try {
      // Set the default payment method on the customer
      PaymentMethod pm = PaymentMethod.retrieve(
        postBody.getPaymentMethodId()
      );
      pm.attach(
        PaymentMethodAttachParams
          .builder()
          .setCustomer(customer.getId())
          .build()
      );
    } catch (CardException e) {
      // Since it's a decline, CardException will be caught
      Map<String, String> responseErrorMessage = new HashMap<>();
      responseErrorMessage.put("message", e.getLocalizedMessage());
      Map<String, Object> responseError = new HashMap<>();
      responseError.put("error", responseErrorMessage);

      return gson.toJson(responseError);
    }

    CustomerUpdateParams customerUpdateParams = CustomerUpdateParams
      .builder()
      .setInvoiceSettings(
        CustomerUpdateParams
          .InvoiceSettings.builder()
          .setDefaultPaymentMethod(postBody.getPaymentMethodId())
          .build()
      )
      .build();

    customer.update(customerUpdateParams);

    // Create the subscription
    SubscriptionCreateParams subCreateParams = SubscriptionCreateParams
      .builder()
      .addItem(
        SubscriptionCreateParams
          .Item.builder()
          .setPrice("price_HGd7M3DV3IMXkC")
          .build()
      )
      .setCustomer(customer.getId())
      .addAllExpand(Arrays.asList("latest_invoice.payment_intent"))
      .build();

    Subscription subscription = Subscription.create(subCreateParams);

    return subscription.toJson();
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/create-subscription', async (req, res) => {
  // Attach the payment method to the customer
  try {
    await stripe.paymentMethods.attach(req.body.paymentMethodId, {
      customer: req.body.customerId,
    });
  } catch (error) {
    return res.status('402').send({ error: { message: error.message } });
  }

  // Change the default invoice settings on the customer to the new payment method
  await stripe.customers.update(
    req.body.customerId,
    {
      invoice_settings: {
        default_payment_method: req.body.paymentMethodId,
      },
    }
  );

  // Create the subscription
  const subscription = await stripe.subscriptions.create({
    customer: req.body.customerId,
    items: [{ price: 'price_HGd7M3DV3IMXkC' }],
    expand: ['latest_invoice.payment_intent'],
  });

  res.send(subscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/create-subscription', async (req, res) => {
  // Attach the payment method to the customer
  try {
    await stripe.paymentMethods.attach(req.body.paymentMethodId, {
      customer: req.body.customerId,
    });
  } catch (error) {
    return res.status('402').send({ error: { message: error.message } });
  }

  // Change the default invoice settings on the customer to the new payment method
  await stripe.customers.update(
    req.body.customerId,
    {
      invoice_settings: {
        default_payment_method: req.body.paymentMethodId,
      },
    }
  );

  // Create the subscription
  const subscription = await stripe.subscriptions.create({
    customer: req.body.customerId,
    items: [{ price: 'price_HGd7M3DV3IMXkC' }],
    expand: ['latest_invoice.payment_intent'],
  });

  res.send(subscription);
});

func handleCreateSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    PaymentMethodID string `json:"paymentMethodId"`
    CustomerID      string `json:"customerId"`
    PriceID         string `json:"priceId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  // Attach PaymentMethod
  params := &stripe.PaymentMethodAttachParams{
    Customer: stripe.String(req.CustomerID),
  }
  pm, err := paymentmethod.Attach(
    req.PaymentMethodID,
    params,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Attach: %v %s", err, pm.ID)
    return
  }
  // Update invoice settings default
  customerParams := &stripe.CustomerParams{
    InvoiceSettings: &stripe.CustomerInvoiceSettingsParams{
      DefaultPaymentMethod: stripe.String(pm.ID),
    },
  }
  c, err := customer.Update(
    req.CustomerID,
    customerParams,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.Update: %v %s", err, c.ID)
    return
  }
  // Create subscription
  subscriptionParams := &stripe.SubscriptionParams{
    Customer: stripe.String(req.CustomerID),
    Items: []*stripe.SubscriptionItemsParams{
      {
        Plan: stripe.String(os.Getenv(req.PriceID)),
      },
    },
  }
  subscriptionParams.AddExpand("latest_invoice.payment_intent")
  s, err := sub.New(subscriptionParams)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.New: %v", err)
    return
  }
  writeJSON(w, s)
}
func handleCreateSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    PaymentMethodID string `json:"paymentMethodId"`
    CustomerID      string `json:"customerId"`
    PriceID         string `json:"priceId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  // Attach PaymentMethod
  params := &stripe.PaymentMethodAttachParams{
    Customer: stripe.String(req.CustomerID),
  }
  pm, err := paymentmethod.Attach(
    req.PaymentMethodID,
    params,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Attach: %v %s", err, pm.ID)
    return
  }
  // Update invoice settings default
  customerParams := &stripe.CustomerParams{
    InvoiceSettings: &stripe.CustomerInvoiceSettingsParams{
      DefaultPaymentMethod: stripe.String(pm.ID),
    },
  }
  c, err := customer.Update(
    req.CustomerID,
    customerParams,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.Update: %v %s", err, c.ID)
    return
  }
  // Create subscription
  subscriptionParams := &stripe.SubscriptionParams{
    Customer: stripe.String(req.CustomerID),
    Items: []*stripe.SubscriptionItemsParams{
      {
        Plan: stripe.String(os.Getenv(req.PriceID)),
      },
    },
  }
  subscriptionParams.AddExpand("latest_invoice.payment_intent")
  s, err := sub.New(subscriptionParams)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.New: %v", err)
    return
  }
  writeJSON(w, s)
}

using Newtonsoft.Json;

public class CreateSubscriptionRequest
{
    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }

    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("priceId")]
    public string Price { get; set; }
}
using Newtonsoft.Json;

public class CreateSubscriptionRequest
{
    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }

    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("priceId")]
    public string Price { get; set; }
}

[HttpPost("create-subscription")]
public ActionResult<Subscription> CreateSubscription([FromBody] CreateSubscriptionRequest req)
{
    // Attach payment method
    var options = new PaymentMethodAttachOptions
    {
        Customer = req.Customer,
    };
    var service = new PaymentMethodService();
    var paymentMethod = service.Attach(req.PaymentMethod, options);

    // Update customer's default invoice payment method
    var customerOptions = new CustomerUpdateOptions
    {
        InvoiceSettings = new CustomerInvoiceSettingsOptions
        {
            DefaultPaymentMethod = paymentMethod.Id,
        },
    };
    var customerService = new CustomerService();
    customerService.Update(req.Customer, customerOptions);

    // Create subscription
    var subscriptionOptions = new SubscriptionCreateOptions
    {
        Customer = req.Customer,
        Items = new List<SubscriptionItemOptions>
        {
            new SubscriptionItemOptions
            {
                Price = Environment.GetEnvironmentVariable(req.Price),
            },
        },
    };
    subscriptionOptions.AddExpand("latest_invoice.payment_intent");
    var subscriptionService = new SubscriptionService();
    try
    {
        Subscription subscription = subscriptionService.Create(subscriptionOptions);
        return subscription;
    }
    catch (StripeException e)
    {
        Console.WriteLine($"Failed to create subscription.{e}");
        return BadRequest();
    }
}
[HttpPost("create-subscription")]
public ActionResult<Subscription> CreateSubscription([FromBody] CreateSubscriptionRequest req)
{
    // Attach payment method
    var options = new PaymentMethodAttachOptions
    {
        Customer = req.Customer,
    };
    var service = new PaymentMethodService();
    var paymentMethod = service.Attach(req.PaymentMethod, options);

    // Update customer's default invoice payment method
    var customerOptions = new CustomerUpdateOptions
    {
        InvoiceSettings = new CustomerInvoiceSettingsOptions
        {
            DefaultPaymentMethod = paymentMethod.Id,
        },
    };
    var customerService = new CustomerService();
    customerService.Update(req.Customer, customerOptions);

    // Create subscription
    var subscriptionOptions = new SubscriptionCreateOptions
    {
        Customer = req.Customer,
        Items = new List<SubscriptionItemOptions>
        {
            new SubscriptionItemOptions
            {
                Price = Environment.GetEnvironmentVariable(req.Price),
            },
        },
    };
    subscriptionOptions.AddExpand("latest_invoice.payment_intent");
    var subscriptionService = new SubscriptionService();
    try
    {
        Subscription subscription = subscriptionService.Create(subscriptionOptions);
        return subscription;
    }
    catch (StripeException e)
    {
        Console.WriteLine($"Failed to create subscription.{e}");
        return BadRequest();
    }
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retry-invoice' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  begin
    Stripe::PaymentMethod.attach(
      data['paymentMethodId'],
      { customer: data['customerId'] }
    )
  rescue Stripe::CardError => e
    halt 200,
         { 'Content-Type' => 'application/json' },
         { 'error': { message: e.error.message } }.to_json
  end

  # Set the default payment method on the customer
  Stripe::Customer.update(
    data['customerId'],
    invoice_settings: { default_payment_method: data['paymentMethodId'] }
  )

  invoice =
    Stripe::Invoice.retrieve(
      { id: data['invoiceId'], expand: %w[payment_intent] }
    )

  invoice.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retry-invoice' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  begin
    Stripe::PaymentMethod.attach(
      data['paymentMethodId'],
      { customer: data['customerId'] }
    )
  rescue Stripe::CardError => e
    halt 200,
         { 'Content-Type' => 'application/json' },
         { 'error': { message: e.error.message } }.to_json
  end

  # Set the default payment method on the customer
  Stripe::Customer.update(
    data['customerId'],
    invoice_settings: { default_payment_method: data['paymentMethodId'] }
  )

  invoice =
    Stripe::Invoice.retrieve(
      { id: data['invoiceId'], expand: %w[payment_intent] }
    )

  invoice.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retry-invoice', methods=['POST'])
def retrySubscription():
    data = json.loads(request.data)
    try:

        stripe.PaymentMethod.attach(
            data['paymentMethodId'],
            customer=data['customerId'],
        )
        # Set the default payment method on the customer
        stripe.Customer.modify(
            data['customerId'],
            invoice_settings={
                'default_payment_method': data['paymentMethodId'],
            },
        )

        invoice = stripe.Invoice.retrieve(
            data['invoiceId'],
            expand=['payment_intent'],
        )
        return jsonify(invoice)
    except Exception as e:
        return jsonify(error={'message': str(e)}), 200
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retry-invoice', methods=['POST'])
def retrySubscription():
    data = json.loads(request.data)
    try:

        stripe.PaymentMethod.attach(
            data['paymentMethodId'],
            customer=data['customerId'],
        )
        # Set the default payment method on the customer
        stripe.Customer.modify(
            data['customerId'],
            invoice_settings={
                'default_payment_method': data['paymentMethodId'],
            },
        )

        invoice = stripe.Invoice.retrieve(
            data['invoiceId'],
            expand=['payment_intent'],
        )
        return jsonify(invoice)
    except Exception as e:
        return jsonify(error={'message': str(e)}), 200

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retry-invoice', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  try {
    $payment_method = $stripe->paymentMethods->retrieve(
      $body->paymentMethodId
    );
    $payment_method->attach([
      'customer' => $body->customerId,
    ]);
  } catch (Exception $e) {
    return $response->withJson($e->jsonBody);
  }


  // Set the default payment method on the customer
  $stripe->customers->update($body->customerId, [
    'invoice_settings' => [
      'default_payment_method' => $body->paymentMethodId
    ]
  ]);

  $invoice = $stripe->invoices->retrieve($body->invoiceId, [
    'expand' => ['payment_intent']
  ]);

  return $response->withJson($invoice);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retry-invoice', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  try {
    $payment_method = $stripe->paymentMethods->retrieve(
      $body->paymentMethodId
    );
    $payment_method->attach([
      'customer' => $body->customerId,
    ]);
  } catch (Exception $e) {
    return $response->withJson($e->jsonBody);
  }


  // Set the default payment method on the customer
  $stripe->customers->update($body->customerId, [
    'invoice_settings' => [
      'default_payment_method' => $body->paymentMethodId
    ]
  ]);

  $invoice = $stripe->invoices->retrieve($body->invoiceId, [
    'expand' => ['payment_intent']
  ]);

  return $response->withJson($invoice);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retry-invoice",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    RetryInvoiceBody postBody = gson.fromJson(
      request.body(),
      RetryInvoiceBody.class
    );
    Customer customer = Customer.retrieve(postBody.getCustomerId());

    try {
      // Set the default payment method on the customer
      PaymentMethod pm = PaymentMethod.retrieve(
        postBody.getPaymentMethodId()
      );
      pm.attach(
        PaymentMethodAttachParams
          .builder()
          .setCustomer(customer.getId())
          .build()
      );
    } catch (CardException e) {
      // Since it's a decline, CardException will be caught
      Map<String, String> responseErrorMessage = new HashMap<>();
      responseErrorMessage.put("message", e.getLocalizedMessage());
      Map<String, Object> responseError = new HashMap<>();
      responseError.put("error", responseErrorMessage);
      return gson.toJson(responseError);
    }

    CustomerUpdateParams customerUpdateParams = CustomerUpdateParams
      .builder()
      .setInvoiceSettings(
        CustomerUpdateParams
          .InvoiceSettings.builder()
          .setDefaultPaymentMethod(postBody.getPaymentMethodId())
          .build()
      )
      .build();

    customer.update(customerUpdateParams);

    InvoiceRetrieveParams params = InvoiceRetrieveParams
      .builder()
      .addAllExpand(Arrays.asList("payment_intent"))
      .build();

    Invoice invoice = Invoice.retrieve(
      postBody.getInvoiceId(),
      params,
      null
    );

    return invoice.toJson();
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retry-invoice",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    RetryInvoiceBody postBody = gson.fromJson(
      request.body(),
      RetryInvoiceBody.class
    );
    Customer customer = Customer.retrieve(postBody.getCustomerId());

    try {
      // Set the default payment method on the customer
      PaymentMethod pm = PaymentMethod.retrieve(
        postBody.getPaymentMethodId()
      );
      pm.attach(
        PaymentMethodAttachParams
          .builder()
          .setCustomer(customer.getId())
          .build()
      );
    } catch (CardException e) {
      // Since it's a decline, CardException will be caught
      Map<String, String> responseErrorMessage = new HashMap<>();
      responseErrorMessage.put("message", e.getLocalizedMessage());
      Map<String, Object> responseError = new HashMap<>();
      responseError.put("error", responseErrorMessage);
      return gson.toJson(responseError);
    }

    CustomerUpdateParams customerUpdateParams = CustomerUpdateParams
      .builder()
      .setInvoiceSettings(
        CustomerUpdateParams
          .InvoiceSettings.builder()
          .setDefaultPaymentMethod(postBody.getPaymentMethodId())
          .build()
      )
      .build();

    customer.update(customerUpdateParams);

    InvoiceRetrieveParams params = InvoiceRetrieveParams
      .builder()
      .addAllExpand(Arrays.asList("payment_intent"))
      .build();

    Invoice invoice = Invoice.retrieve(
      postBody.getInvoiceId(),
      params,
      null
    );

    return invoice.toJson();
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retry-invoice', async (req, res) => {
  // Set the default payment method on the customer

  try {
    await stripe.paymentMethods.attach(req.body.paymentMethodId, {
      customer: req.body.customerId,
    });
    await stripe.customers.update(req.body.customerId, {
      invoice_settings: {
        default_payment_method: req.body.paymentMethodId,
      },
    });
  } catch (error) {
    // in case card_decline error
    return res
      .status('402')
      .send({ result: { error: { message: error.message } } });
  }

  const invoice = await stripe.invoices.retrieve(req.body.invoiceId, {
    expand: ['payment_intent'],
  });
  res.send(invoice);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retry-invoice', async (req, res) => {
  // Set the default payment method on the customer

  try {
    await stripe.paymentMethods.attach(req.body.paymentMethodId, {
      customer: req.body.customerId,
    });
    await stripe.customers.update(req.body.customerId, {
      invoice_settings: {
        default_payment_method: req.body.paymentMethodId,
      },
    });
  } catch (error) {
    // in case card_decline error
    return res
      .status('402')
      .send({ result: { error: { message: error.message } } });
  }

  const invoice = await stripe.invoices.retrieve(req.body.invoiceId, {
    expand: ['payment_intent'],
  });
  res.send(invoice);
});

func handleRetryInvoice(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var req struct {
    CustomerID      string `json:"customerId"`
    PaymentMethodID string `json:"paymentMethodId"`
    InvoiceID       string `json:"invoiceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  // Attach PaymentMethod
  params := &stripe.PaymentMethodAttachParams{
    Customer: stripe.String(req.CustomerID),
  }
  pm, err := paymentmethod.Attach(
    req.PaymentMethodID,
    params,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Attach: %v %s", err, pm.ID)
    return
  }

  // Update invoice settings default
  customerParams := &stripe.CustomerParams{
    InvoiceSettings: &stripe.CustomerInvoiceSettingsParams{
      DefaultPaymentMethod: stripe.String(pm.ID),
    },
  }
  c, err := customer.Update(
    req.CustomerID,
    customerParams,
  )

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.Update: %v %s", err, c.ID)
    return
  }

  // Retrieve Invoice
  invoiceParams := &stripe.InvoiceParams{}
  invoiceParams.AddExpand("payment_intent")
  in, err := invoice.Get(
    req.InvoiceID,
    invoiceParams,
  )

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("invoice.Get: %v", err)
    return
  }

  writeJSON(w, in)
}
func handleRetryInvoice(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var req struct {
    CustomerID      string `json:"customerId"`
    PaymentMethodID string `json:"paymentMethodId"`
    InvoiceID       string `json:"invoiceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  // Attach PaymentMethod
  params := &stripe.PaymentMethodAttachParams{
    Customer: stripe.String(req.CustomerID),
  }
  pm, err := paymentmethod.Attach(
    req.PaymentMethodID,
    params,
  )
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Attach: %v %s", err, pm.ID)
    return
  }

  // Update invoice settings default
  customerParams := &stripe.CustomerParams{
    InvoiceSettings: &stripe.CustomerInvoiceSettingsParams{
      DefaultPaymentMethod: stripe.String(pm.ID),
    },
  }
  c, err := customer.Update(
    req.CustomerID,
    customerParams,
  )

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("customer.Update: %v %s", err, c.ID)
    return
  }

  // Retrieve Invoice
  invoiceParams := &stripe.InvoiceParams{}
  invoiceParams.AddExpand("payment_intent")
  in, err := invoice.Get(
    req.InvoiceID,
    invoiceParams,
  )

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("invoice.Get: %v", err)
    return
  }

  writeJSON(w, in)
}

using Newtonsoft.Json;

public class RetryInvoiceRequest
{
    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }

    [JsonProperty("invoiceId")]
    public string Invoice { get; set; }
}
using Newtonsoft.Json;

public class RetryInvoiceRequest
{
    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }

    [JsonProperty("invoiceId")]
    public string Invoice { get; set; }
}

[HttpPost("retry-invoice")]
public ActionResult<Invoice> RetryInvoice([FromBody] RetryInvoiceRequest req)
{
    // Attach payment method
    var options = new PaymentMethodAttachOptions
    {
        Customer = req.Customer,
    };
    var service = new PaymentMethodService();
    var paymentMethod = service.Attach(req.PaymentMethod, options);

    // Update customer's default invoice payment method
    var customerOptions = new CustomerUpdateOptions
    {
        InvoiceSettings = new CustomerInvoiceSettingsOptions
        {
            DefaultPaymentMethod = paymentMethod.Id,
        },
    };
    var customerService = new CustomerService();
    customerService.Update(req.Customer, customerOptions);

    var invoiceOptions = new InvoiceGetOptions();
    invoiceOptions.AddExpand("payment_intent");
    var invoiceService = new InvoiceService();
    Invoice invoice = invoiceService.Get(req.Invoice, invoiceOptions);
    return invoice;
}
[HttpPost("retry-invoice")]
public ActionResult<Invoice> RetryInvoice([FromBody] RetryInvoiceRequest req)
{
    // Attach payment method
    var options = new PaymentMethodAttachOptions
    {
        Customer = req.Customer,
    };
    var service = new PaymentMethodService();
    var paymentMethod = service.Attach(req.PaymentMethod, options);

    // Update customer's default invoice payment method
    var customerOptions = new CustomerUpdateOptions
    {
        InvoiceSettings = new CustomerInvoiceSettingsOptions
        {
            DefaultPaymentMethod = paymentMethod.Id,
        },
    };
    var customerService = new CustomerService();
    customerService.Update(req.Customer, customerOptions);

    var invoiceOptions = new InvoiceGetOptions();
    invoiceOptions.AddExpand("payment_intent");
    var invoiceService = new InvoiceService();
    Invoice invoice = invoiceService.Get(req.Invoice, invoiceOptions);
    return invoice;
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/cancel-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  deleted_subscription = Stripe::Subscription.delete(data['subscriptionId'])

  deleted_subscription.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/cancel-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  deleted_subscription = Stripe::Subscription.delete(data['subscriptionId'])

  deleted_subscription.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/cancel-subscription', methods=['POST'])
def cancelSubscription():
    data = json.loads(request.data)
    try:
         # Cancel the subscription by deleting it
        deletedSubscription = stripe.Subscription.delete(data['subscriptionId'])
        return jsonify(deletedSubscription)
    except Exception as e:
        return jsonify(error=str(e)), 403
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/cancel-subscription', methods=['POST'])
def cancelSubscription():
    data = json.loads(request.data)
    try:
         # Cancel the subscription by deleting it
        deletedSubscription = stripe.Subscription.delete(data['subscriptionId'])
        return jsonify(deletedSubscription)
    except Exception as e:
        return jsonify(error=str(e)), 403

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/cancel-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());

  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve(
    $body->subscriptionId
  );
  $subscription->delete();

  return $response->withJson($subscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/cancel-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());

  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve(
    $body->subscriptionId
  );
  $subscription->delete();

  return $response->withJson($subscription);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
      "/cancel-subscription",
      (request, response) -> {
        response.type("application/json");
        // Set the default payment method on the customer
        CancelPostBody postBody = gson.fromJson(
          request.body(),
          CancelPostBody.class
        );

        Subscription subscription = Subscription.retrieve(
          postBody.getSubscriptionId()
        );

        Subscription deletedSubscription = subscription.cancel();
        return deletedSubscription.toJson();
      }
    );
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
      "/cancel-subscription",
      (request, response) -> {
        response.type("application/json");
        // Set the default payment method on the customer
        CancelPostBody postBody = gson.fromJson(
          request.body(),
          CancelPostBody.class
        );

        Subscription subscription = Subscription.retrieve(
          postBody.getSubscriptionId()
        );

        Subscription deletedSubscription = subscription.cancel();
        return deletedSubscription.toJson();
      }
    );

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/cancel-subscription', async (req, res) => {
  // Delete the subscription
  const deletedSubscription = await stripe.subscriptions.del(
    req.body.subscriptionId
  );
  res.send(deletedSubscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/cancel-subscription', async (req, res) => {
  // Delete the subscription
  const deletedSubscription = await stripe.subscriptions.del(
    req.body.subscriptionId
  );
  res.send(deletedSubscription);
});

func handleCancelSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    SubscriptionID string `json:"subscriptionId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  s, err := sub.Cancel(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Cancel: %v", err)
    return
  }
  writeJSON(w, s)
}
func handleCancelSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    SubscriptionID string `json:"subscriptionId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }
  s, err := sub.Cancel(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Cancel: %v", err)
    return
  }
  writeJSON(w, s)
}

using Newtonsoft.Json;

public class CancelSubscriptionRequest
{
    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }
}
using Newtonsoft.Json;

public class CancelSubscriptionRequest
{
    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }
}

[HttpPost("cancel-subscription")]
public ActionResult<Subscription> CancelSubscription([FromBody] CancelSubscriptionRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Cancel(req.Subscription, null);
    return subscription;
}
[HttpPost("cancel-subscription")]
public ActionResult<Subscription> CancelSubscription([FromBody] CancelSubscriptionRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Cancel(req.Subscription, null);
    return subscription;
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/update-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  updated_subscription =
    Stripe::Subscription.update(
      data['subscriptionId'],
      cancel_at_period_end: false,
      items: [
        { id: subscription.items.data[0].id, price: 'price_H1NlVtpo6ubk0m' }
      ]
    )

  updated_subscription.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/update-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  updated_subscription =
    Stripe::Subscription.update(
      data['subscriptionId'],
      cancel_at_period_end: false,
      items: [
        { id: subscription.items.data[0].id, price: 'price_H1NlVtpo6ubk0m' }
      ]
    )

  updated_subscription.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/update-subscription', methods=['POST'])
def updateSubscription():
    data = json.loads(request.data)
    try:
        subscription = stripe.Subscription.retrieve(data['subscriptionId'])

        updatedSubscription = stripe.Subscription.modify(
            data['subscriptionId'],
            cancel_at_period_end=False,
            items=[{
                'id': subscription['items']['data'][0].id,
                'price': 'price_H1NlVtpo6ubk0m',
            }]
        )
        return jsonify(updatedSubscription)
    except Exception as e:
        return jsonify(error=str(e)), 403
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/update-subscription', methods=['POST'])
def updateSubscription():
    data = json.loads(request.data)
    try:
        subscription = stripe.Subscription.retrieve(data['subscriptionId'])

        updatedSubscription = stripe.Subscription.modify(
            data['subscriptionId'],
            cancel_at_period_end=False,
            items=[{
                'id': subscription['items']['data'][0].id,
                'price': 'price_H1NlVtpo6ubk0m',
            }]
        )
        return jsonify(updatedSubscription)
    except Exception as e:
        return jsonify(error=str(e)), 403

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/update-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve($body->subscriptionId);

  $updatedSubscription = $stripe->subscriptions->update($body->subscriptionId, [
    'items' => [
      [
        'id' => $subscription->items->data[0]->id,
        'price' => 'price_H1NlVtpo6ubk0m',
      ],
    ],
  ]);

  return $response->withJson($updatedSubscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/update-subscription', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve($body->subscriptionId);

  $updatedSubscription = $stripe->subscriptions->update($body->subscriptionId, [
    'items' => [
      [
        'id' => $subscription->items->data[0]->id,
        'price' => 'price_H1NlVtpo6ubk0m',
      ],
    ],
  ]);

  return $response->withJson($updatedSubscription);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/update-subscription",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    UpdatePostBody postBody = gson.fromJson(
      request.body(),
      UpdatePostBody.class
    );

    Subscription subscription = Subscription.retrieve(
      postBody.getSubscriptionId()
    );

    SubscriptionUpdateParams params = SubscriptionUpdateParams
      .builder()
      .addItem(
        SubscriptionUpdateParams
          .Item.builder()
          .setId(subscription.getItems().getData().get(0).getId())
          .setPrice("price_H1NlVtpo6ubk0m")
          .build()
      )
      .setCancelAtPeriodEnd(false)
      .build();

    subscription.update(params);
    return subscription.toJson();
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/update-subscription",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    UpdatePostBody postBody = gson.fromJson(
      request.body(),
      UpdatePostBody.class
    );

    Subscription subscription = Subscription.retrieve(
      postBody.getSubscriptionId()
    );

    SubscriptionUpdateParams params = SubscriptionUpdateParams
      .builder()
      .addItem(
        SubscriptionUpdateParams
          .Item.builder()
          .setId(subscription.getItems().getData().get(0).getId())
          .setPrice("price_H1NlVtpo6ubk0m")
          .build()
      )
      .setCancelAtPeriodEnd(false)
      .build();

    subscription.update(params);
    return subscription.toJson();
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/update-subscription', async (req, res) => {
  const subscription = await stripe.subscriptions.retrieve(
    req.body.subscriptionId
  );
  const updatedSubscription = await stripe.subscriptions.update(
    req.body.subscriptionId,
    {
      cancel_at_period_end: false,
      items: [
        {
          id: subscription.items.data[0].id,
          price: "price_H1NlVtpo6ubk0m",
        },
      ],
    }
  );

  res.send(updatedSubscription);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/update-subscription', async (req, res) => {
  const subscription = await stripe.subscriptions.retrieve(
    req.body.subscriptionId
  );
  const updatedSubscription = await stripe.subscriptions.update(
    req.body.subscriptionId,
    {
      cancel_at_period_end: false,
      items: [
        {
          id: subscription.items.data[0].id,
          price: "price_H1NlVtpo6ubk0m",
        },
      ],
    }
  );

  res.send(updatedSubscription);
});

func handleUpdateSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var req struct {
    SubscriptionID string `json:"subscriptionId"`
    NewPriceID     string `json:"newPriceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  s, err := sub.Get(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Get: %v", err)
    return
  }

  params := &stripe.SubscriptionParams{
    CancelAtPeriodEnd: stripe.Bool(false),
    Items: []*stripe.SubscriptionItemsParams{{
      ID:    stripe.String(s.Items.Data[0].ID),
      Price: stripe.String("price_H1NlVtpo6ubk0m"),
    }},
  }

  updatedSubscription, err := sub.Update(req.SubscriptionID, params)

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Update: %v", err)
    return
  }

  writeJSON(w, updatedSubscription)
}
func handleUpdateSubscription(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }

  var req struct {
    SubscriptionID string `json:"subscriptionId"`
    NewPriceID     string `json:"newPriceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  s, err := sub.Get(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Get: %v", err)
    return
  }

  params := &stripe.SubscriptionParams{
    CancelAtPeriodEnd: stripe.Bool(false),
    Items: []*stripe.SubscriptionItemsParams{{
      ID:    stripe.String(s.Items.Data[0].ID),
      Price: stripe.String("price_H1NlVtpo6ubk0m"),
    }},
  }

  updatedSubscription, err := sub.Update(req.SubscriptionID, params)

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Update: %v", err)
    return
  }

  writeJSON(w, updatedSubscription)
}

using Newtonsoft.Json;

public class UpdateSubscriptionRequest
{
    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }

    [JsonProperty("newPriceId")]
    public string NewPrice { get; set; }
}
using Newtonsoft.Json;

public class UpdateSubscriptionRequest
{
    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }

    [JsonProperty("newPriceId")]
    public string NewPrice { get; set; }
}

[HttpPost("update-subscription")]
public ActionResult<Subscription> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Get(req.Subscription);

    var options = new SubscriptionUpdateOptions
    {
        CancelAtPeriodEnd = false,
        Items = new List<SubscriptionItemOptions>
        {
            new SubscriptionItemOptions
            {
                Id = subscription.Items.Data[0].Id,
                Price = "price_H1NlVtpo6ubk0m",
            }
        }
    };
    var updatedSubscription = service.Update(req.Subscription, options);
    return updatedSubscription;
}
[HttpPost("update-subscription")]
public ActionResult<Subscription> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Get(req.Subscription);

    var options = new SubscriptionUpdateOptions
    {
        CancelAtPeriodEnd = false,
        Items = new List<SubscriptionItemOptions>
        {
            new SubscriptionItemOptions
            {
                Id = subscription.Items.Data[0].Id,
                Price = "price_H1NlVtpo6ubk0m",
            }
        }
    };
    var updatedSubscription = service.Update(req.Subscription, options);
    return updatedSubscription;
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retrieve-upcoming-invoice' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  invoice =
    Stripe::Invoice.upcoming(
      customer: data['customerId'],
      subscription: data['subscriptionId'],
      subscription_items: [
        { id: subscription.items.data[0].id, deleted: true },
        { price: ENV[data['newPriceId']], deleted: false }
      ]
    )

  invoice.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retrieve-upcoming-invoice' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  invoice =
    Stripe::Invoice.upcoming(
      customer: data['customerId'],
      subscription: data['subscriptionId'],
      subscription_items: [
        { id: subscription.items.data[0].id, deleted: true },
        { price: ENV[data['newPriceId']], deleted: false }
      ]
    )

  invoice.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retrieve-upcoming-invoice', methods=['POST'])
def retrieveUpcomingInvoice():
    data = json.loads(request.data)
    try:
        # Retrieve the subscription
        subscription = stripe.Subscription.retrieve(data['subscriptionId'])

        # Retrieve the invoice
        invoice = stripe.Invoice.upcoming(
            customer=data['customerId'],
            subscription=data['subscriptionId'],
            subscription_items=[
                {
                    'id': subscription['items']['data'][0].id,
                    'deleted': True,
                },
                {
                    'price': 'price_H1NlVtpo6ubk0m',
                    'deleted': False,
                }
            ],
        )
        return jsonify(invoice)
    except Exception as e:
        return jsonify(error=str(e)), 403
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retrieve-upcoming-invoice', methods=['POST'])
def retrieveUpcomingInvoice():
    data = json.loads(request.data)
    try:
        # Retrieve the subscription
        subscription = stripe.Subscription.retrieve(data['subscriptionId'])

        # Retrieve the invoice
        invoice = stripe.Invoice.upcoming(
            customer=data['customerId'],
            subscription=data['subscriptionId'],
            subscription_items=[
                {
                    'id': subscription['items']['data'][0].id,
                    'deleted': True,
                },
                {
                    'price': 'price_H1NlVtpo6ubk0m',
                    'deleted': False,
                }
            ],
        )
        return jsonify(invoice)
    except Exception as e:
        return jsonify(error=str(e)), 403

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retrieve-upcoming-invoice', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve(
    $body->subscriptionId
  );

  $invoice = $stripe->invoices->upcoming([
    "customer" => $body->customerId,
    "subscription_prorate" => true,
    "subscription" => $body->subscriptionId,
    "subscription_items" => [
      [
        'id' => $subscription->items->data[0]->id,
        'deleted' => true
      ],
      [
        'price' => getenv($body->newPriceId),
        'deleted' => false
      ],
    ]
  ]);

  return $response->withJson($invoice);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retrieve-upcoming-invoice', function (Request $request, Response $response, array $args) {
  $body = json_decode($request->getBody());
  $stripe = $this->stripe;

  $subscription = $stripe->subscriptions->retrieve(
    $body->subscriptionId
  );

  $invoice = $stripe->invoices->upcoming([
    "customer" => $body->customerId,
    "subscription_prorate" => true,
    "subscription" => $body->subscriptionId,
    "subscription_items" => [
      [
        'id' => $subscription->items->data[0]->id,
        'deleted' => true
      ],
      [
        'price' => getenv($body->newPriceId),
        'deleted' => false
      ],
    ]
  ]);

  return $response->withJson($invoice);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retrieve-upcoming-invoice",
  (request, response) -> {
    response.type("application/json");
    UpcomingInvoicePostBody postBody = gson.fromJson(
      request.body(),
      UpcomingInvoicePostBody.class
    );

    Subscription subscription = Subscription.retrieve(
      postBody.getSubscriptionId()
    );

    InvoiceUpcomingParams invoiceParams = InvoiceUpcomingParams
      .builder()
      .setCustomer(postBody.getCustomerId())
      .setSubscription(postBody.getSubscriptionId())
      .addSubscriptionItem(
        InvoiceUpcomingParams
          .SubscriptionItem.builder()
          .setId(subscription.getItems().getData().get(0).getId())
          .setDeleted(true)
          .build()
      )
      .addSubscriptionItem(
        InvoiceUpcomingParams
          .SubscriptionItem.builder()
          .setPrice(dotenv.get(postBody.getNewPriceId().toUpperCase()))
          .build()
      )
      .build();

    Invoice invoice = Invoice.upcoming(invoiceParams);

    return invoice.toJson();
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retrieve-upcoming-invoice",
  (request, response) -> {
    response.type("application/json");
    UpcomingInvoicePostBody postBody = gson.fromJson(
      request.body(),
      UpcomingInvoicePostBody.class
    );

    Subscription subscription = Subscription.retrieve(
      postBody.getSubscriptionId()
    );

    InvoiceUpcomingParams invoiceParams = InvoiceUpcomingParams
      .builder()
      .setCustomer(postBody.getCustomerId())
      .setSubscription(postBody.getSubscriptionId())
      .addSubscriptionItem(
        InvoiceUpcomingParams
          .SubscriptionItem.builder()
          .setId(subscription.getItems().getData().get(0).getId())
          .setDeleted(true)
          .build()
      )
      .addSubscriptionItem(
        InvoiceUpcomingParams
          .SubscriptionItem.builder()
          .setPrice(dotenv.get(postBody.getNewPriceId().toUpperCase()))
          .build()
      )
      .build();

    Invoice invoice = Invoice.upcoming(invoiceParams);

    return invoice.toJson();
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retrieve-upcoming-invoice', async (req, res) => {
  const subscription = await stripe.subscriptions.retrieve(
    req.body.subscriptionId
  );

  const invoice = await stripe.invoices.retrieveUpcoming({
    subscription_prorate: true,
    customer: req.body.customerId,
    subscription: req.body.subscriptionId,
    subscription_items: [
      {
        id: subscription.items.data[0].id,
        deleted: true,
      },
      {
        // This price ID is the price you want to change the subscription to.
        price: 'price_H1NlVtpo6ubk0m',
        deleted: false,
      },
    ],
  });
  res.send(invoice);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retrieve-upcoming-invoice', async (req, res) => {
  const subscription = await stripe.subscriptions.retrieve(
    req.body.subscriptionId
  );

  const invoice = await stripe.invoices.retrieveUpcoming({
    subscription_prorate: true,
    customer: req.body.customerId,
    subscription: req.body.subscriptionId,
    subscription_items: [
      {
        id: subscription.items.data[0].id,
        deleted: true,
      },
      {
        // This price ID is the price you want to change the subscription to.
        price: 'price_H1NlVtpo6ubk0m',
        deleted: false,
      },
    ],
  });
  res.send(invoice);
});

func handleRetrieveUpcomingInvoice(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    SubscriptionID string `json:"subscriptionId"`
    CustomerID     string `json:"customerId"`
    NewPriceID     string `json:"newPriceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  s, err := sub.Get(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Get: %v", err)
    return
  }
  params := &stripe.InvoiceParams{
    Customer:     stripe.String(req.CustomerID),
    Subscription: stripe.String(req.SubscriptionID),
    SubscriptionItems: []*stripe.SubscriptionItemsParams{{
      ID:      stripe.String(s.Items.Data[0].ID),
      Deleted: stripe.Bool(true),
    }, {
      Price:   stripe.String(os.Getenv(req.NewPriceID)),
      Deleted: stripe.Bool(false),
    }},
  }
  in, err := invoice.GetNext(params)

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("invoice.GetNext: %v", err)
    return
  }

  writeJSON(w, in)
}
func handleRetrieveUpcomingInvoice(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    SubscriptionID string `json:"subscriptionId"`
    CustomerID     string `json:"customerId"`
    NewPriceID     string `json:"newPriceId"`
  }

  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  s, err := sub.Get(req.SubscriptionID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("sub.Get: %v", err)
    return
  }
  params := &stripe.InvoiceParams{
    Customer:     stripe.String(req.CustomerID),
    Subscription: stripe.String(req.SubscriptionID),
    SubscriptionItems: []*stripe.SubscriptionItemsParams{{
      ID:      stripe.String(s.Items.Data[0].ID),
      Deleted: stripe.Bool(true),
    }, {
      Price:   stripe.String(os.Getenv(req.NewPriceID)),
      Deleted: stripe.Bool(false),
    }},
  }
  in, err := invoice.GetNext(params)

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("invoice.GetNext: %v", err)
    return
  }

  writeJSON(w, in)
}

using Newtonsoft.Json;

public class RetrieveUpcomingInvoiceRequest
{
    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }

    [JsonProperty("newPriceId")]
    public string NewPrice { get; set; }
}
using Newtonsoft.Json;

public class RetrieveUpcomingInvoiceRequest
{
    [JsonProperty("customerId")]
    public string Customer { get; set; }

    [JsonProperty("subscriptionId")]
    public string Subscription { get; set; }

    [JsonProperty("newPriceId")]
    public string NewPrice { get; set; }
}

[HttpPost("retrieve-upcoming-invoice")]
public ActionResult<Invoice> RetrieveUpcomingInvoice([FromBody] RetrieveUpcomingInvoiceRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Get(req.Subscription);

    var invoiceService = new InvoiceService();
    var options = new UpcomingInvoiceOptions
    {
        Customer = req.Customer,
        Subscription = req.Subscription,
        SubscriptionItems = new List<InvoiceSubscriptionItemOptions>
        {
            new InvoiceSubscriptionItemOptions
            {
                Id = subscription.Items.Data[0].Id,
                Deleted = true,
            },
            new InvoiceSubscriptionItemOptions
            {
                // TODO: This should be Price, but isn't in Stripe.net yet.
                Plan = Environment.GetEnvironmentVariable(req.NewPrice),
                Deleted = false,
            },
        }
    };
    Invoice upcoming = invoiceService.Upcoming(options);
    return upcoming;
}
[HttpPost("retrieve-upcoming-invoice")]
public ActionResult<Invoice> RetrieveUpcomingInvoice([FromBody] RetrieveUpcomingInvoiceRequest req)
{
    var service = new SubscriptionService();
    var subscription = service.Get(req.Subscription);

    var invoiceService = new InvoiceService();
    var options = new UpcomingInvoiceOptions
    {
        Customer = req.Customer,
        Subscription = req.Subscription,
        SubscriptionItems = new List<InvoiceSubscriptionItemOptions>
        {
            new InvoiceSubscriptionItemOptions
            {
                Id = subscription.Items.Data[0].Id,
                Deleted = true,
            },
            new InvoiceSubscriptionItemOptions
            {
                // TODO: This should be Price, but isn't in Stripe.net yet.
                Plan = Environment.GetEnvironmentVariable(req.NewPrice),
                Deleted = false,
            },
        }
    };
    Invoice upcoming = invoiceService.Upcoming(options);
    return upcoming;
}

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retrieve-customer-payment-method' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  payment_method = Stripe::PaymentMethod.retrieve(data['paymentMethodId'])

  payment_method.to_json
end
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

post '/retrieve-customer-payment-method' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  payment_method = Stripe::PaymentMethod.retrieve(data['paymentMethodId'])

  payment_method.to_json
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retrieve-customer-payment-method', methods=['POST'])
def retrieveCustomerPaymentMethod():
    data = json.loads(request.data)
    try:
        paymentMethod = stripe.PaymentMethod.retrieve(
            data['paymentMethodId'],
        )
        return jsonify(paymentMethod)
    except Exception as e:
        return jsonify(error=str(e)), 403
# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/retrieve-customer-payment-method', methods=['POST'])
def retrieveCustomerPaymentMethod():
    data = json.loads(request.data)
    try:
        paymentMethod = stripe.PaymentMethod.retrieve(
            data['paymentMethodId'],
        )
        return jsonify(paymentMethod)
    except Exception as e:
        return jsonify(error=str(e)), 403

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retrieve-customer-payment-method', function (
    Request $request,
    Response $response,
    array $args
) {
    $body = json_decode($request->getBody());
    $stripe = $this->stripe;

    $paymentMethod = $stripe->paymentMethods->retrieve($body->paymentMethodId);

    return $response->withJson($paymentMethod);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$app->post('/retrieve-customer-payment-method', function (
    Request $request,
    Response $response,
    array $args
) {
    $body = json_decode($request->getBody());
    $stripe = $this->stripe;

    $paymentMethod = $stripe->paymentMethods->retrieve($body->paymentMethodId);

    return $response->withJson($paymentMethod);
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retrieve-customer-payment-method",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    PaymentMethodBody paymentMethodBody = gson.fromJson(
      request.body(),
      PaymentMethodBody.class
    );

    PaymentMethod paymentMethod = PaymentMethod.retrieve(
      paymentMethodBody.getPaymentMethodId()
    );
    return paymentMethod.toJson();
  }
);
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

post(
  "/retrieve-customer-payment-method",
  (request, response) -> {
    response.type("application/json");
    // Set the default payment method on the customer
    PaymentMethodBody paymentMethodBody = gson.fromJson(
      request.body(),
      PaymentMethodBody.class
    );

    PaymentMethod paymentMethod = PaymentMethod.retrieve(
      paymentMethodBody.getPaymentMethodId()
    );
    return paymentMethod.toJson();
  }
);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retrieve-customer-payment-method', async (req, res) => {
  const paymentMethod = await stripe.paymentMethods.retrieve(
    req.body.paymentMethodId
  );

  res.send(paymentMethod);
});
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

app.post('/retrieve-customer-payment-method', async (req, res) => {
  const paymentMethod = await stripe.paymentMethods.retrieve(
    req.body.paymentMethodId
  );

  res.send(paymentMethod);
});

func handleRetrieveCustomerPaymentMethod(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    PaymentMethodID string `json:"paymentMethodId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  pm, err := paymentmethod.Get(req.PaymentMethodID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Get: %v", err)
    return
  }

  writeJSON(w, pm)
}
func handleRetrieveCustomerPaymentMethod(w http.ResponseWriter, r *http.Request) {
  if r.Method != "POST" {
    http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
    return
  }
  var req struct {
    PaymentMethodID string `json:"paymentMethodId"`
  }
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("json.NewDecoder.Decode: %v", err)
    return
  }

  pm, err := paymentmethod.Get(req.PaymentMethodID, nil)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    log.Printf("paymentmethod.Get: %v", err)
    return
  }

  writeJSON(w, pm)
}

using Newtonsoft.Json;

public class RetrieveCustomerPaymentMethodRequest
{
    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }
}
using Newtonsoft.Json;

public class RetrieveCustomerPaymentMethodRequest
{
    [JsonProperty("paymentMethodId")]
    public string PaymentMethod { get; set; }
}

[HttpPost("retrieve-customer-payment-method")]
public ActionResult<PaymentMethod> RetrieveCustomerPaymentMethod([FromBody] RetrieveCustomerPaymentMethodRequest req)
{
    var service = new PaymentMethodService();
    var paymentMethod = service.Get(req.PaymentMethod);
    return paymentMethod;
}
[HttpPost("retrieve-customer-payment-method")]
public ActionResult<PaymentMethod> RetrieveCustomerPaymentMethod([FromBody] RetrieveCustomerPaymentMethodRequest req)
{
    var service = new PaymentMethodService();
    var paymentMethod = service.Get(req.PaymentMethod);
    return paymentMethod;
}