Este tutorial está diseñado para guiar a quienes desean aprender más acerca de Stripe. Es ideal para un nivel medio.
Stripe es una plataforma de tecnología financiera líder que permite a negocios de todos los tamaños aceptar pagos en línea de forma segura, gestionar suscripciones, emitir facturas y construir plataformas complejas. Con un enfoque API-first, Stripe proporciona SDKs robustos para los lenguajes de programación más populares, facilitando a los desarrolladores integrar funcionalidades de pago avanzadas tanto en el lado del servidor como del cliente. Esta guía de nivel intermedio explora los productos clave de Stripe (como Checkout para páginas de pago alojadas, Elements para formularios personalizados, Billing para gestión de suscripciones y facturación recurrente, y Radar para prevención de fraude), la importancia de manejar eventos asíncronos mediante Webhooks, la gestión de Claves API (modo test y live), y las consideraciones de seguridad (ayuda con cumplimiento PCI). Cubre cómo usar el Dashboard de Stripe para monitorear transacciones y clientes, y la infraestructura que proporciona para manejar diversas formas de pago globalmente.
El 'Hola, mundo' de Stripe: crear un checkout simple y seguro con Stripe usando Python y el microframework web Flask. Este código configura una sesión de checkout del lado del servidor para redirigir al cliente a una página de pago alojada por Stripe.
# **Prerrequisitos:** Instalar Flask (pip install Flask) y el SDK de Stripe (pip install stripe).
# Asegurate de tener tu clave secreta de prueba de Stripe (empieza con sk_test_...).
# **Nota:** Este es solo el codigo del lado del servidor para crear la sesion.
# Para que esto funcione, necesitas ejecutar esta aplicacion Flask y tener una URL publica (ej: usando ngrok) para las success_url y cancel_url que Stripe pueda redirigir al cliente.
import stripe
import os # Para cargar la clave API de forma segura
from flask import Flask, redirect
app = Flask(__name__)
# Cargar clave secreta de Stripe de forma segura (recomendado via variable de entorno)
stripe.api_key = os.getenv('STRIPE_SECRET_KEY')
# Define la ruta para iniciar el checkout
@app.route('/create-checkout-session', methods=['POST']) # Comunmente es POST, no GET
def create_checkout_session():
try:
session = stripe.checkout.Session.create(
line_items=[{
'price_data': {
'currency': 'usd',
'product_data': {
'name': 'Taza de Café Especial',
'description': 'Una taza de ceramica de alta calidad.'
},
'unit_amount': 2000, # Monto en la unidad mas pequeña de la moneda (20.00 USD)
},
'quantity': 1,
}],
mode='payment', # O 'subscription' para suscripciones
success_url='https://tudominio.com/success?session_id={CHECKOUT_SESSION_ID}', # URL a la que redirigir tras pago exitoso
cancel_url='https://tudominio.com/cancel', # URL a la que redirigir si el cliente cancela
# Opcional: añadir customer, metadata, etc.
)
# Redirige al cliente a la URL del Checkout de Stripe
return redirect(session.url, code=303)
except Exception as e:
return str(e)
# Rutas de ejemplo para manejar la redireccion de Stripe (necesitan implementacion real)
@app.route('/success')
def success():
# Aqui puedes mostrar un mensaje de exito al cliente.
# Para confirmar el pago de forma segura, es mejor usar Webhooks (evento checkout.session.completed).
return '¡Pago exitoso! Gracias por tu compra.'
@app.route('/cancel')
def cancel():
# Aqui puedes mostrar un mensaje al cliente si cancelo el checkout.
return 'Checkout cancelado.'
# Para ejecutar la app (solo para desarrollo):
# if __name__ == '__main__':
# app.run(port=4242)
Resultado:
Al acceder a la ruta '/create-checkout-session' (ej: con un formulario POST), el servidor crea una sesión de Checkout en Stripe y redirige al usuario a una página de pago segura alojada en stripe.com para completar la transacción. Tras el pago, el usuario es redirigido a `success_url` o `cancel_url`.
Familiarizarse con estos comandos es esencial para interactuar eficientemente con Stripe:
pip install stripe # Python
npm install stripe # Node.js
composer require stripe/stripe-php # PHP
# Consulta la documentacion de Stripe para otros lenguajes (Ruby, Java, Go, etc.)
1. Accede al Dashboard de Stripe (https://dashboard.stripe.com).
2. Ve a 'Developers' -> 'API keys'.
3. Obtén tu clave pública (`pk_test_...`, `pk_live_...`) y clave secreta (`sk_test_...`, `sk_live_...`).
4. Configura `stripe.api_key = 'TU_CLAVE_SECRETA'` en tu código **del lado del servidor**. Usa variables de entorno (`os.getenv('STRIPE_SECRET_KEY')`) para la clave secreta.
5. Usa tu clave **pública** en el lado del cliente (frontend) para inicializar Stripe.js o Elements.
# En tu backend, con el SDK de Stripe configurado:
session = stripe.checkout.Session.create(
line_items=[{ 'price': 'price_123', 'quantity': 1 }], # Usar ID de Precio creado en Dashboard/API
mode='payment', # O 'subscription'
success_url='https://tudominio.com/success?session_id={CHECKOUT_SESSION_ID}',
cancel_url='https://tudominio.com/cancel',
# ... otros parametros ...
)
# Luego, redirige al cliente a session.url desde tu frontend o backend.
# Opción 1: Dashboard (Recomendado para empezar)
# Accede a https://dashboard.stripe.com -> Products -> + Add product.
# Opción 2: Via API (en tu backend)
product = stripe.Product.create(
name='Mi Producto Digital',
description='Una descripción genial.'
)
price = stripe.Price.create(
product=product.id, # Usar el ID del producto creado
unit_amount=1500, # Monto en la unidad mas pequeña
currency='eur',
recurring={'interval': 'month'} # O null para pago unico
)
# En tu backend:
customer = stripe.Customer.create(
email='nuevo.cliente@email.com',
name='Juan Perez',
description='Cliente creado durante registro',
# ... añadir metadata util (ID de usuario en tu sistema) ...
metadata={'my_user_id': 'user_123'}
)
# Guarda el customer.id (cus_...) en tu base de datos.
# 1. En tu backend, crea una ruta POST (ej: '/webhook').
# 2. Obtén el payload JSON y el header 'Stripe-Signature' del request entrante.
# 3. Usa `stripe.Webhook.construct_event()` para verificar la firma y construir el objeto de evento.
# webhook_secret = os.getenv('STRIPE_WEBHOOK_SECRET') # Obtener del Dashboard
# event = stripe.Webhook.construct_event(payload, sig_header, webhook_secret)
# 4. Dentro de un `try...except`, procesa el `event.type` (ej: 'checkout.session.completed', 'customer.subscription.updated', etc.).
# 5. Devuelve una respuesta HTTP 200 OK a Stripe **rapidamente** despues de verificar la firma, incluso si el procesamiento del evento es asincrono.
# Requiere codigo frontend (HTML/JS) y backend.
# 1. Backend: Crea un PaymentIntent y envia su `client_secret` al frontend.
# 2. Frontend (HTML): Incluye el script de Stripe.js `<script src="https://js.stripe.com/v3/"></script>`. Ten un formulario HTML con contenedores (ej: `<div>`) para los Elements.
# 3. Frontend (JS): Inicializa Stripe `const stripe = Stripe('pk_test_...')`. Crea una instancia de `elements = stripe.elements()`. Crea elementos individuales (`const cardElement = elements.create('card');`). Monta los elementos en los contenedores HTML (`cardElement.mount('#card-element');`).
# 4. Frontend (JS, al enviar formulario): Usa `stripe.confirmCardPayment(clientSecret, { payment_method: { card: cardElement } })` (u otro metodo similar) para tokenizar la tarjeta y completar el pago sin que la informacion sensible pase por tu servidor.
# Opción 1: En tu `success_url` (tras redireccion de Checkout/Elements)
# Obtén el `session_id` de la URL (ej: `/success?session_id=cs_test_...`).
# En tu backend, usa `session = stripe.checkout.Session.retrieve(session_id)` para obtener detalles y verificar el estado (`payment_status`).
# Opción 2: Usando Webhooks (Recomendado para fiabilidad)
# Configura un Webhook para el evento `checkout.session.completed`. Este evento se envia cuando la sesion de checkout se ha completado y el pago ha sido procesado. Es mas fiable que solo confiar en la redireccion del navegador.
Consulta la documentación de Stripe (https://stripe.com/docs/testing#cards) para ver números de tarjetas de prueba válidos y para simular diferentes escenarios (pago exitoso, fondos insuficientes, error de autenticación, etc.).
Accede a https://dashboard.stripe.com. Usa las secciones 'Payments' (pagos, reembolsos, disputas), 'Customers', 'Subscriptions', 'Products', 'Developers' -> 'Webhooks' (ver eventos recibidos/fallidos), 'Developers' -> 'Logs' (ver logs de API).
# 1. Instala Stripe CLI (consulta docs.stripe.com/stripe-cli).
# 2. Inicia el reenvio de eventos a tu endpoint local (ej: Flask app corriendo en puerto 4242):
stripe listen --forward-to localhost:4242/webhook
# 3. En otra terminal, activa un evento (ej: un checkout): `stripe trigger checkout.session.completed`
Desde el Dashboard de Stripe, sigue el checklist 'Go live'. Esto implica verificar tu identidad/negocio, configurar tu cuenta bancaria para recibir depósitos y, crucialmente, reemplazar tus claves API de prueba (`sk_test_`, `pk_test_`) por las claves 'live' (`sk_live_`, `pk_live_`) en tu código de producción.
Comprender estos conceptos fundamentales te ayudará a dominar Stripe de forma más organizada y eficiente:
Enfoque API-First:
La filosofía central de diseño de Stripe. Toda su funcionalidad está expuesta a través de una API RESTful coherente y bien documentada. Esto proporciona a los desarrolladores la máxima flexibilidad para integrar pagos y servicios financieros en sus aplicaciones, controlando completamente la experiencia del usuario y el flujo de negocio.
Productos Clave de Stripe:
El conjunto modular de herramientas de Stripe: **Checkout** (páginas de pago alojadas y optimizadas, la forma más rápida de integrar pagos únicos o suscripciones), **Elements** (componentes de UI seguros y personalizables para construir formularios de pago propios en tu sitio, manteniendo PCI simple), **Billing** (suite completa para gestionar suscripciones y facturación recurrente), **Invoicing** (para crear y enviar facturas), **Connect** (para construir marketplaces y plataformas), y **Radar** (prevención de fraude con ML).
Tipos de Integración (Server-side vs Client-side):
La integración con Stripe requiere una distinción clara entre código que se ejecuta en tu **servidor** (backend) y código en el **navegador** del usuario (frontend). Las operaciones sensibles (crear cargos, usar claves secretas) siempre deben estar en el backend. El frontend interactúa con Stripe.js/Elements para recopilar información de pago de forma segura y tokenizarla antes de enviarla a tu backend.
Objetos de la API de Stripe:
Las entidades fundamentales con las que interactúas a través de la API. Ejemplos: `Customer` (quién compra), `Product` (qué se vende), `Price` (cuánto cuesta y cómo se factura), `PaymentIntent` (el ciclo de vida de un pago único), `Charge` (el resultado de un intento de pago), `Subscription` (un acuerdo de pago recurrente), `Invoice` (una factura generada).
Webhooks:
Mecanismo de notificación esencial. Son llamadas HTTP POST que Stripe realiza a un endpoint en tu servidor para informarte sobre eventos que suceden en tu cuenta (ej: `payment_intent.succeeded`, `customer.subscription.created`, `invoice.paid`). Son cruciales para actualizar el estado de tu aplicación de forma fiable en respuesta a eventos asíncronos.
Stripe Dashboard:
La interfaz web (dashboard.stripe.com) para gestionar tu cuenta. Permite visualizar y administrar pagos, clientes, suscripciones, productos. También es donde obtienes tus claves API, configuras webhooks, revisas logs, disputas y accedes a informes y analíticas. Indispensable para la operación diaria.
Claves API (Publishable Key, Secret Key):
Las credenciales para autenticarte con la API de Stripe. La **Publishable Key** (`pk_...`) identifica tu cuenta y se usa en el frontend (es segura para ser pública). La **Secret Key** (`sk_...`) otorga permisos completos y **siempre** debe manejarse de forma segura en tu backend, idealmente usando variables de entorno.
Modo Test vs Modo Live:
Dos entornos separados para el desarrollo y la producción. El **Test Mode** (con claves de prueba) simula transacciones sin usar dinero real. El **Live Mode** (con claves 'live') procesa pagos reales. Siempre desarrolla y prueba exhaustivamente en modo test antes de pasar a modo live.
Seguridad y Cumplimiento PCI:
Stripe simplifica enormemente el cumplimiento PCI DSS. Al usar sus soluciones de frontend (Checkout, Elements, Stripe.js), la información sensible de las tarjetas se maneja directamente entre el navegador del cliente y Stripe, sin tocar tus servidores. Esto reduce el alcance de tus responsabilidades de seguridad, aunque aún debes proteger tus claves secretas y usar webhooks seguros.
Manejo de Pagos (Únicos y Recurrentes) y Métodos de Pago:
Stripe soporta pagos **únicos** (via PaymentIntents/Charges) y **recurrentes** (via Subscriptions/Invoices). Ofrece una amplia gama de **métodos de pago** globales (tarjetas, billeteras digitales) y locales (débito bancario, transferencias, etc.), permitiéndote aceptar pagos de clientes en todo el mundo.
Stripe CLI:
Una herramienta de línea de comandos que agiliza el desarrollo con Stripe, especialmente útil para probar y depurar webhooks localmente, monitorear eventos en tiempo real o realizar llamadas a la API desde la terminal.
Proceso de 'Go Live':
El conjunto de pasos requeridos para pasar de usar Stripe en modo test a aceptar pagos reales. Incluye verificar tu identidad/negocio, configurar tu cuenta bancaria para depósitos y actualizar tus claves API de prueba a las claves 'live' en tu aplicación de producción.
Algunos ejemplos de aplicaciones prácticas donde se utiliza Stripe:
Ventas online de productos físicos o digitales:
Integrar Stripe Checkout o Elements en tu tienda online o e-commerce para aceptar pagos únicos por productos en carritos de compra o ventas directas. Manejar múltiples productos y calcular totales fácilmente.
Implementar modelos de negocio basados en suscripciones y membresías:
Utilizar Stripe Billing para gestionar planes de suscripción con facturación recurrente (mensual, anual, por uso, etc.). Automatizar la creación de facturas, el cobro automático, las pruebas gratuitas, los cambios de plan y la gestión de estados de suscripción.
Desarrollar plataformas SaaS con facturación flexible:
Integrar Stripe en aplicaciones SaaS para cobrar a los usuarios por el acceso a funcionalidades, niveles de servicio o basado en el uso. Combinar Billing con la API para crear modelos de precios complejos y automatizar la facturación.
Implementar formularios de pago totalmente personalizados en tu sitio web o aplicación móvil (usando Stripe Elements):
Controlar el diseño y la experiencia de usuario de tus formularios de pago para que se ajusten a tu marca, mientras Stripe.js y Elements manejan la recopilación segura de la información de la tarjeta, simplificando el cumplimiento PCI.
Construir un marketplace o plataforma que facilite pagos entre compradores y vendedores (Stripe Connect):
Utilizar la infraestructura de Stripe Connect para manejar los flujos de dinero en una plataforma donde varios vendedores venden a compradores. Permite cobrar pagos, dividir fondos, gestionar cuentas para los vendedores y encargarte de aspectos de cumplimiento.
Implementar reglas avanzadas de prevención de fraude y Machine Learning (Stripe Radar):
Aprovechar el sistema de detección de fraude integrado de Stripe para analizar cada transacción, identificar y bloquear pagos sospechosos, y configurar reglas personalizadas para minimizar el riesgo de contracargos y pérdidas por fraude.
Automatizar la creación, envío y gestión del estado de facturas para clientes (Stripe Invoicing):
Utilizar Stripe Invoicing para generar facturas profesionales manualmente o de forma automatizada para tus clientes, enviarlas por correo electrónico, gestionar su estado (pagada, pendiente) y conciliar los pagos recibidos directamente en tu cuenta.
Aceptar una amplia gama de métodos de pago locales e internacionales para optimizar la conversión global:
Configurar tu integración para aceptar no solo tarjetas de crédito/débito globales, sino también métodos de pago populares en regiones específicas (ej: débito bancario europeo, transferencias bancarias, métodos locales) para facilitar que los clientes paguen en su método preferido.
Crear flujos de pago personalizados que se adapten a lógicas de negocio específicas o requisitos complejos:
Diseñar la secuencia exacta de interacciones con la API de Stripe (creación de PaymentIntent, confirmación, manejo de autenticación 3D Secure, etc.) para construir experiencias de checkout a medida que se ajusten a flujos de usuario o requisitos de negocio complejos no cubiertos por las soluciones preconstruidas.
Monitorear, analizar y gestionar todas las transacciones, clientes y suscripciones desde el Dashboard y vía API:
Utilizar el Dashboard web para obtener visibilidad completa de la actividad de pagos, realizar acciones manuales (reembolsos, ajustes de suscripciones), generar informes y analizar métricas clave. O usar la API para automatizar estas tareas en tu propio sistema de administración.
Aquí tienes algunas recomendaciones para facilitar tus inicios en Stripe:
Crea una Cuenta de Stripe y Familiarízate con el Dashboard:
Regístrate en stripe.com. El Dashboard (dashboard.stripe.com) es donde gestionarás todo. Explora las secciones de Pagos, Clientes, Productos, y la importante sección de Developers (para API keys, Webhooks, Logs).
Entiende la Diferencia Fundamental entre Modo Test y Modo Live:
Stripe tiene dos entornos: **Test** (pruebas gratuitas con dinero ficticio, usando claves `sk_test_...`/`pk_test_...`) y **Live** (pagos reales, usando claves `sk_live_...`/`pk_live_...`). Siempre desarrolla y prueba en modo test. Solo cambia a live cuando tu integración esté completa y verificada.
Obtén Tus Claves API (Pública y Secreta) y Configúralas de Forma Segura:
En el Dashboard (Developers -> API keys), obtén tus claves de prueba y live. Tu **clave secreta** (`sk_...`) da acceso total a tu cuenta y **siempre** debe estar en tu backend, idealmente cargada desde una variable de entorno (`STRIPE_SECRET_KEY`). Tu **clave pública** (`pk_...`) se usa en el frontend y puede estar en tu código JavaScript.
Empieza con Stripe Checkout para Tu Primera Integración de Pagos Únicos:
Checkout es la forma más rápida de aceptar pagos únicos. Creas una `Session` en tu backend y rediriges al cliente a la página de pago alojada por Stripe. Es la forma más sencilla de empezar y te ayuda con el cumplimiento PCI desde el inicio.
Comprende la Importancia de los Webhooks para Eventos Post-Pago:
Los webhooks son esenciales para saber si un pago fue realmente exitoso, si una suscripción cambió de estado, etc. Configura un endpoint en tu servidor que Stripe pueda llamar y escucha eventos clave (ej: `checkout.session.completed`). La Stripe CLI es muy útil para probarlos localmente (`stripe listen`).
Utiliza las Tarjetas de Prueba de Stripe para Testear Tu Integración a Fondo:
Stripe proporciona números de tarjetas de prueba especiales (en la documentación y en el Dashboard). Úsalos en modo test para simular transacciones exitosas, fallidas, autenticaciones 3D Secure, etc. Prueba todos los flujos posibles.
Lee la Documentación de Stripe - Es Muy Completa:
La documentación oficial (stripe.com/docs) es excelente y tu mejor recurso. Tiene guías detalladas para cada producto (Checkout, Billing, Elements, etc.), referencia completa de la API para todos los lenguajes, y guías sobre seguridad y mejores prácticas.
Explora el Dashboard para Monitorear Tu Actividad y Resolver Problemas:
El Dashboard no es solo para configuraciones. Úsalo para ver el estado de cada pago, cliente o suscripción. La sección 'Developers' -> 'Logs' es crucial para ver si tus llamadas a la API tuvieron éxito o fallaron y por qué. La sección 'Webhooks' te muestra si Stripe pudo enviar los eventos a tu endpoint.
Ten en Cuenta la Seguridad: PCI Compliance y Manejo de Claves:
Al usar las soluciones de frontend de Stripe, simplificas mucho PCI. Pero es vital proteger tu clave secreta (¡nunca en el frontend!) y verificar la firma de los webhooks para asegurar que provienen de Stripe.
Cuando estés listo, completa el Proceso de 'Go Live':
Una vez que tu integración funcione perfectamente en modo test y hayas configurado tus productos/precios, sigue el checklist 'Go live' en el Dashboard. Implica proporcionar información de tu negocio y cambiar a las claves API 'live' en tu entorno de producción.
Si te interesa Stripe, también podrías explorar estas herramientas:
Amplía tus conocimientos con estos enlaces y materiales: