Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/BEKO2210/Firstbrain --skill stripe-integrationLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Métiers associés SOC
Basé sur la classification professionnelle SOC
name stripe-integration description Master Stripe payment processing integration for robust, PCI-compliant payment flows including checkout, subscriptions, webhooks, and refunds. type skill created 2026-02-27T00:00:00.000Z domain business-marketing category ecommerce risk unknown source community tags ["skill","business-marketing","ecommerce","stripe","integration"]
Stripe Integration
Master Stripe payment processing integration for robust, PCI-compliant payment flows including checkout, subscriptions, webhooks, and refunds.
Do not use this skill when
The task is unrelated to stripe integration
You need a different domain or tool outside this scope
Instructions
Clarify goals, constraints, and required inputs.
Apply relevant best practices and validate outcomes.
Provide actionable steps and verification.
If detailed examples are required, open resources/implementation-playbook.md.
Use this skill when
Implementing payment processing in web/mobile applications
Setting up subscription billing systems
Handling one-time payments and recurring charges
Processing refunds and disputes
Managing customer payment methods
Implementing SCA (Strong Customer Authentication) for European payments
Building marketplace payment flows with Stripe Connect
Core Concepts
1. Payment Flows
Checkout Session (Hosted)
Stripe-hosted payment page
Minimal PCI compliance burden
Fastest implementation
Supports one-time and recurring payments
Payment Intents (Custom UI)
Full control over payment UI
Requires Stripe.js for PCI compliance
More complex implementation
Better customization options
Setup Intents (Save Payment Methods)
Collect payment method without charging
Used for subscriptions and future payments
Requires customer confirmation
2. Webhooks
Critical Events:
payment_intent.succeeded: Payment completedpayment_intent.payment_failed: Payment failedcustomer.subscription.updated: Subscription changedcustomer.subscription.deleted: Subscription canceledcharge.refunded: Refund processedinvoice.payment_succeeded: Subscription payment successful
3. Subscriptions
Components:
Product : What you're selling
Price : How much and how often
Subscription : Customer's recurring payment
Invoice : Generated for each billing cycle
4. Customer Management
Create and manage customer records
Store multiple payment methods
Track customer metadata
Manage billing details
Quick Start import stripe
stripe.api_key = "sk_test_..."
session = stripe.checkout.Session.create(
payment_method_types=['card' ],
line_items=[{
'price_data' : {
'currency' : 'usd' ,
'product_data' : {
'name' : 'Premium Subscription' ,
},
'unit_amount' : 2000 ,
'recurring' : {
'interval' : 'month' ,
},
},
'quantity' : 1 ,
}],
mode='subscription' ,
success_url='https://yourdomain.com/success?session_id={CHECKOUT_SESSION_ID}' ,
cancel_url='https://yourdomain.com/cancel' ,
)
print (session.url)
Payment Implementation Patterns
Pattern 1: One-Time Payment (Hosted Checkout) def create_checkout_session (amount, currency='usd' ):
"""Create a one-time payment checkout session."""
try :
session = stripe.checkout.Session.create(
payment_method_types=['card' ],
line_items=[{
'price_data' : {
'currency' : currency,
'product_data' : {
'name' : 'Purchase' ,
'images' : ['https://example.com/product.jpg' ],
},
'unit_amount' : amount,
},
'quantity' : 1 ,
}],
mode='payment' ,
success_url='https://yourdomain.com/success?session_id={CHECKOUT_SESSION_ID}' ,
cancel_url='https://yourdomain.com/cancel' ,
metadata={
'order_id' : 'order_123' ,
'user_id' : 'user_456'
}
)
return session
except stripe.error.StripeError as e:
print (f"Stripe error: {e.user_message} " )
raise
Pattern 2: Custom Payment Intent Flow def create_payment_intent (amount, currency='usd' , customer_id=None ):
"""Create a payment intent for custom checkout UI."""
intent = stripe.PaymentIntent.create(
amount=amount,
currency=currency,
customer=customer_id,
automatic_payment_methods={
'enabled' : True ,
},
metadata={
'integration_check' : 'accept_a_payment'
}
)
return intent.client_secret
"""
const stripe = Stripe('pk_test_...');
const elements = stripe.elements();
const cardElement = elements.create('card');
cardElement.mount('#card-element');
const {error, paymentIntent} = await stripe.confirmCardPayment(
clientSecret,
{
payment_method: {
card: cardElement,
billing_details: {
name: 'Customer Name'
}
}
}
);
if (error) {
// Handle error
} else if (paymentIntent.status === 'succeeded') {
// Payment successful
}
"""
Pattern 3: Subscription Creation def create_subscription (customer_id, price_id ):
"""Create a subscription for a customer."""
try :
subscription = stripe.Subscription.create(
customer=customer_id,
items=[{'price' : price_id}],
payment_behavior='default_incomplete' ,
payment_settings={'save_default_payment_method' : 'on_subscription' },
expand=['latest_invoice.payment_intent' ],
)
return {
'subscription_id' : subscription.id ,
'client_secret' : subscription.latest_invoice.payment_intent.client_secret
}
except stripe.error.StripeError as e:
print (f"Subscription creation failed: {e} " )
raise
Pattern 4: Customer Portal def create_customer_portal_session (customer_id ):
"""Create a portal session for customers to manage subscriptions."""
session = stripe.billing_portal.Session.create(
customer=customer_id,
return_url='https://yourdomain.com/account' ,
)
return session.url
Webhook Handling
Secure Webhook Endpoint from flask import Flask, request
import stripe
app = Flask(__name__)
endpoint_secret = 'whsec_...'
@app.route('/webhook' , methods=['POST' ]
def webhook ():
payload = request.data
sig_header = request.headers.get('Stripe-Signature' )
try :
event = stripe.Webhook.construct_event(
payload, sig_header, endpoint_secret
)
except ValueError:
return 'Invalid payload' , 400
except stripe.error.SignatureVerificationError:
return 'Invalid signature' , 400
if event['type' ] == 'payment_intent.succeeded' :
payment_intent = event['data' ]['object' ]
handle_successful_payment(payment_intent)
elif event['type' ] == 'payment_intent.payment_failed' :
payment_intent = event['data' ]['object' ]
handle_failed_payment(payment_intent)
elif event['type' ] == 'customer.subscription.deleted' :
subscription = event['data' ]['object' ]
handle_subscription_canceled(subscription)
return 'Success' , 200
def handle_successful_payment (payment_intent ):
"""Process successful payment."""
customer_id = payment_intent.get('customer' )
amount = payment_intent['amount' ]
metadata = payment_intent.get('metadata' , {})
print (f"Payment succeeded: {payment_intent['id' ]} " )
def handle_failed_payment (payment_intent ):
"""Handle failed payment."""
error = payment_intent.get('last_payment_error' , {})
print (f"Payment failed: {error.get('message' )} " )
def handle_subscription_canceled (subscription ):
"""Handle subscription cancellation."""
customer_id = subscription['customer' ]
print (f"Subscription canceled: {subscription['id' ]} " )
Webhook Best Practices import hashlib
import hmac
def verify_webhook_signature (payload, signature, secret ):
"""Manually verify webhook signature."""
expected_sig = hmac.new(
secret.encode('utf-8' ),
payload,
hashlib.sha256
).hexdigest()
return hmac.compare_digest(signature, expected_sig)
def handle_webhook_idempotently (event_id, handler ):
"""Ensure webhook is processed exactly once."""
if is_event_processed(event_id):
return
try :
handler()
mark_event_processed(event_id)
except Exception as e:
log_error(e)
raise
Customer Management def create_customer (email, name, payment_method_id=None ):
"""Create a Stripe customer."""
customer = stripe.Customer.create(
email=email,
name=name,
payment_method=payment_method_id,
invoice_settings={
'default_payment_method' : payment_method_id
} if payment_method_id else None ,
metadata={
'user_id' : '12345'
}
)
return customer
def attach_payment_method (customer_id, payment_method_id ):
"""Attach a payment method to a customer."""
stripe.PaymentMethod.attach(
payment_method_id,
customer=customer_id
)
stripe.Customer.modify(
customer_id,
invoice_settings={
'default_payment_method' : payment_method_id
}
)
def list_customer_payment_methods (customer_id ):
"""List all payment methods for a customer."""
payment_methods = stripe.PaymentMethod.list (
customer=customer_id,
type ='card'
)
return payment_methods.data
Refund Handling def create_refund (payment_intent_id, amount=None , reason=None ):
"""Create a refund."""
refund_params = {
'payment_intent' : payment_intent_id
}
if amount:
refund_params['amount' ] = amount
if reason:
refund_params['reason' ] = reason
refund = stripe.Refund.create(**refund_params)
return refund
def handle_dispute (charge_id, evidence ):
"""Update dispute with evidence."""
stripe.Dispute.modify(
charge_id,
evidence={
'customer_name' : evidence.get('customer_name' ),
'customer_email_address' : evidence.get('customer_email' ),
'shipping_documentation' : evidence.get('shipping_proof' ),
'customer_communication' : evidence.get('communication' ),
}
)
Testing
stripe.api_key = "sk_test_..."
TEST_CARDS = {
'success' : '4242424242424242' ,
'declined' : '4000000000000002' ,
'3d_secure' : '4000002500003155' ,
'insufficient_funds' : '4000000000009995'
}
def test_payment_flow ():
"""Test complete payment flow."""
customer = stripe.Customer.create(
email="test@example.com"
)
intent = stripe.PaymentIntent.create(
amount=1000 ,
currency='usd' ,
customer=customer.id ,
payment_method_types=['card' ]
)
confirmed = stripe.PaymentIntent.confirm(
intent.id ,
payment_method='pm_card_visa'
)
assert confirmed.status == 'succeeded'
Resources
references/checkout-flows.md : Detailed checkout implementationreferences/webhook-handling.md : Webhook security and processingreferences/subscription-management.md : Subscription lifecyclereferences/customer-management.md : Customer and payment method handlingreferences/invoice-generation.md : Invoicing and billingassets/stripe-client.py : Production-ready Stripe client wrapperassets/webhook-handler.py : Complete webhook processorassets/checkout-config.json : Checkout configuration templates
Best Practices
Always Use Webhooks : Don't rely solely on client-side confirmationIdempotency : Handle webhook events idempotentlyError Handling : Gracefully handle all Stripe errorsTest Mode : Thoroughly test with test keys before productionMetadata : Use metadata to link Stripe objects to your databaseMonitoring : Track payment success rates and errorsPCI Compliance : Never handle raw card data on your serverSCA Ready : Implement 3D Secure for European payments
Common Pitfalls
Not Verifying Webhooks : Always verify webhook signaturesMissing Webhook Events : Handle all relevant webhook eventsHardcoded Amounts : Use cents/smallest currency unitNo Retry Logic : Implement retries for API callsIgnoring Test Mode : Test all edge cases with test cards
Connections
Domain: [[Business & Marketing]]Kategorie: [[E-Commerce & Handel]]Navigation: [[Skills Uebersicht]], [[Home]] 