SDK Libraries

npm install @eventop/sdk
# or
yarn add @eventop/sdk

const { Eventop } = require('@eventop/sdk');

// Initialize client
const eventop = new Eventop({
  apiKey: process.env.EVENTOP_API_KEY
});

// Create checkout session
const session = await eventop.checkout.create({
  planId: 'premium-monthly',
  customerEmail: 'user@example.com',
  successUrl: 'https://yourdomain.com/success',
  cancelUrl: 'https://yourdomain.com/pricing'
});

console.log('Checkout URL:', session.url);

import { Eventop, CheckoutSession, Subscription } from '@eventop/sdk';

const eventop = new Eventop({
  apiKey: process.env.EVENTOP_API_KEY!
});

const session: CheckoutSession = await eventop.checkout.create({
  planId: 'premium-monthly',
  customerEmail: 'user@example.com',
  successUrl: 'https://yourdomain.com/success'
});

const session = await eventop.checkout.create({
  planId: 'premium-monthly',
  customerEmail: 'user@example.com',
  customerId: 'user_123', // optional
  successUrl: 'https://yourdomain.com/success',
  cancelUrl: 'https://yourdomain.com/pricing', // optional
  metadata: { userId: '123' } // optional
});

const session = await eventop.checkout.get('session_abc123');

await eventop.checkout.cancel('session_abc123');

const subscriptions = await eventop.subscriptions.list();

const subscription = await eventop.subscriptions.get('ABC123...');

await eventop.subscriptions.cancel('ABC123...');

const isValid = eventop.webhooks.verifySignature(
  req.body,
  req.headers['x-webhook-signature'],
  process.env.EVENTOP_WEBHOOK_SECRET
);

try {
  const event = eventop.webhooks.constructEvent(
    req.body,
    req.headers['x-webhook-signature'],
    process.env.EVENTOP_WEBHOOK_SECRET
  );
  
  console.log('Event:', event.event);
  console.log('Data:', event.data);
} catch (err) {
  console.error('Invalid signature');
}

const { Eventop, EventopError, AuthenticationError, InvalidRequestError } = require('@eventop/sdk');

try {
  const session = await eventop.checkout.create({ ... });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key:', error.message);
  } else if (error instanceof InvalidRequestError) {
    console.error('Invalid request:', error.message);
  } else if (error instanceof EventopError) {
    console.error('API error:', error.message, error.statusCode);
  } else {
    console.error('Unexpected error:', error);
  }
}

const express = require('express');
const { Eventop } = require('@eventop/sdk');

const app = express();
const eventop = new Eventop({
  apiKey: process.env.EVENTOP_API_KEY
});

app.post('/create-subscription', async (req, res) => {
  const { planId } = req.body;
  const user = req.user; // from your auth middleware
  
  try {
    const session = await eventop.checkout.create({
      planId,
      customerEmail: user.email,
      customerId: user.id.toString(),
      successUrl: `${process.env.BASE_URL}/success`,
      cancelUrl: `${process.env.BASE_URL}/pricing`
    });
    
    res.json({ checkoutUrl: session.url });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Webhook endpoint
app.post('/webhooks/eventop', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  
  try {
    const event = eventop.webhooks.constructEvent(
      req.body,
      signature,
      process.env.EVENTOP_WEBHOOK_SECRET
    );
    
    switch (event.event) {
      case 'subscription.created':
        console.log('New subscription:', event.data);
        break;
      // Handle other events...
    }
    
    res.json({ received: true });
  } catch (err) {
    res.status(400).send('Webhook signature verification failed');
  }
});

// pages/api/create-subscription.js
import { Eventop } from '@eventop/sdk';

const eventop = new Eventop({
  apiKey: process.env.EVENTOP_API_KEY
});

export default async function handler(req, res) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }
  
  const { planId, email } = req.body;
  
  try {
    const session = await eventop.checkout.create({
      planId,
      customerEmail: email,
      successUrl: `${process.env.NEXT_PUBLIC_URL}/success`,
      cancelUrl: `${process.env.NEXT_PUBLIC_URL}/pricing`
    });
    
    res.json({ checkoutUrl: session.url });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}