Integração com Stripe

https://api.affiliatus.io/api/campaigns/{SEU_ID}/stripe/webhook

const session = await stripe.checkout.sessions.create({
  payment_method_types: ["card"],
  line_items: [
    {
      price: "price_1234567890",
      quantity: 1,
    },
  ],
  mode: "subscription", // ou 'payment'
  success_url: "https://seusite.com/sucesso",
  cancel_url: "https://seusite.com/cancelado",

  metadata: {
    affiliate_code: "JOAO1", // <- Código do afiliado
  },
});

const session = await stripe.checkout.sessions.create({
  payment_method_types: ["card"],
  line_items: [
    {
      price: "price_1234567890",
      quantity: 1,
    },
  ],
  mode: "subscription",
  success_url: "https://seusite.com/sucesso",
  cancel_url: "https://seusite.com/cancelado",

  discounts: [
    {
      coupon: "JOAO1", // <- Código do cupom = código do afiliado
    },
  ],
});

// pages/api/create-checkout-session.ts
import Stripe from "stripe";
import { NextApiRequest, NextApiResponse } from "next";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse
) {
  if (req.method !== "POST") {
    return res.status(405).json({ error: "Method not allowed" });
  }

  try {
    const { priceId, affiliateCode } = req.body;

    const session = await stripe.checkout.sessions.create({
      payment_method_types: ["card"],
      line_items: [
        {
          price: priceId,
          quantity: 1,
        },
      ],
      mode: "subscription",
      success_url: `${process.env.NEXT_PUBLIC_URL}/sucesso?session_id={CHECKOUT_SESSION_ID}`,
      cancel_url: `${process.env.NEXT_PUBLIC_URL}/cancelado`,

      // Passar código do afiliado no metadata
      metadata: {
        affiliate_code: affiliateCode || null,
      },
    });

    res.status(200).json({ sessionId: session.id });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}

import { loadStripe } from "@stripe/stripe-js";
import { useState, useEffect } from "react";

const stripePromise = loadStripe(process.env.NEXT_PUBLIC_STRIPE_KEY);

export default function CheckoutButton() {
  const [affiliateCode, setAffiliateCode] = useState(null);

  // Capturar código do afiliado do cookie ou URL
  useEffect(() => {
    const urlParams = new URLSearchParams(window.location.search);
    const code = urlParams.get("ref") || getCookie("aff_ref");
    setAffiliateCode(code);
  }, []);

  const handleCheckout = async () => {
    const response = await fetch("/api/create-checkout-session", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        priceId: "price_1234567890",
        affiliateCode: affiliateCode,
      }),
    });

    const { sessionId } = await response.json();
    const stripe = await stripePromise;

    await stripe.redirectToCheckout({ sessionId });
  };

  return <button onClick={handleCheckout}>Assinar Agora</button>;
}

function getCookie(name) {
  const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
  return match ? match[2] : null;
}

const express = require("express");
const stripe = require("stripe")(process.env.STRIPE_SECRET_KEY);
const app = express();

app.post("/create-checkout-session", async (req, res) => {
  const { priceId, affiliateCode } = req.body;

  try {
    const session = await stripe.checkout.sessions.create({
      payment_method_types: ["card"],
      line_items: [{ price: priceId, quantity: 1 }],
      mode: "subscription",
      success_url: "https://seusite.com/sucesso",
      cancel_url: "https://seusite.com/cancelado",

      metadata: {
        affiliate_code: affiliateCode || null,
      },
    });

    res.json({ sessionId: session.id });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000);

use Stripe\Stripe;
use Stripe\Checkout\Session;

Route::post('/create-checkout-session', function (Request $request) {
    Stripe::setApiKey(env('STRIPE_SECRET_KEY'));

    $affiliateCode = $request->cookie('aff_ref') ?? $request->input('ref');

    $session = Session::create([
        'payment_method_types' => ['card'],
        'line_items' => [[
            'price' => 'price_1234567890',
            'quantity' => 1,
        ]],
        'mode' => 'subscription',
        'success_url' => url('/sucesso'),
        'cancel_url' => url('/cancelado'),

        'metadata' => [
            'affiliate_code' => $affiliateCode,
        ],
    ]);

    return response()->json(['sessionId' => $session->id]);
});

import stripe
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

stripe.api_key = os.environ.get('STRIPE_SECRET_KEY')

@csrf_exempt
def create_checkout_session(request):
    if request.method == 'POST':
        affiliate_code = request.COOKIES.get('aff_ref')

        session = stripe.checkout.Session.create(
            payment_method_types=['card'],
            line_items=[{
                'price': 'price_1234567890',
                'quantity': 1,
            }],
            mode='subscription',
            success_url='https://seusite.com/sucesso',
            cancel_url='https://seusite.com/cancelado',

            metadata={
                'affiliate_code': affiliate_code,
            },
        )

        return JsonResponse({'sessionId': session.id})

# Instalar Stripe CLI
brew install stripe/stripe-cli/stripe

# Login
stripe login

# Escutar webhooks localmente
stripe listen --forward-to https://api.affiliatus.io/api/campaigns/SEU_ID/stripe/webhook

# Disparar evento de teste
stripe trigger checkout.session.completed