Integrations - EcoEvents

Extend EcoEvents functionality by integrating with your existing tools and workflows. Connect to calendar systems, communication platforms, payment processors, and more.

Overview

EcoEvents offers integrations with:

Webhooks: Real-time event notifications for custom workflows
Calendar Systems: Google Calendar, Outlook, Apple Calendar
Communication Platforms: Slack, Microsoft Teams, Discord
Payment Processors: Stripe, PayPal, Square
CRM Systems: Salesforce, HubSpot, Pipedrive
Marketing Tools: Mailchimp, SendGrid, Constant Contact
Analytics: Google Analytics, Mixpanel, Segment
Sustainability Tools: Carbon accounting and ESG reporting platforms

All integrations use secure OAuth 2.0 authentication or API keys. Credentials are encrypted at rest and in transit.

Setting Up Webhooks

Webhooks allow you to receive real-time notifications when events occur in EcoEvents.

Create Webhook Endpoint

First, set up an endpoint to receive webhook POST requests:

// Example Express.js webhook endpoint
const express = require('express');
const crypto = require('crypto');

const app = express();
app.use(express.json());

app.post('/webhooks/ecoevents', (req, res) => {
  // Verify webhook signature
  const signature = req.headers['x-ecoevents-signature'];
  const payload = JSON.stringify(req.body);
  const secret = process.env.WEBHOOK_SECRET;
  
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSignature) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process webhook event
  const { event, data } = req.body;
  
  switch (event) {
    case 'registration.created':
      handleNewRegistration(data);
      break;
    case 'event.published':
      handleEventPublished(data);
      break;
    case 'checkin.completed':
      handleCheckin(data);
      break;
    default:
      console.log(`Unhandled event: ${event}`);
  }
  
  res.status(200).send('Webhook received');
});

app.listen(3000);

Navigate to Settings > Integrations > Webhooks:

Click Add Webhook
Enter your endpoint URL
Select events to subscribe to
Save and copy the signing secret
Test the webhook

interface WebhookConfig {
  url: string;
  events: WebhookEvent[];
  enabled: boolean;
  secret: string;
  retryConfig: {
    maxRetries: number;
    backoffMultiplier: number;
  };
}

type WebhookEvent =
  | 'event.created'
  | 'event.updated'
  | 'event.published'
  | 'event.cancelled'
  | 'registration.created'
  | 'registration.updated'
  | 'registration.cancelled'
  | 'checkin.completed'
  | 'payment.completed'
  | 'payment.failed'
  | 'impact.calculated'
  | 'report.generated';

Handle Webhook Events

Process different event types:

async function handleNewRegistration(data) {
  const { attendee, event, registration } = data;
  
  // Add to CRM
  await addToCRM({
    email: attendee.email,
    name: attendee.name,
    company: attendee.company,
    eventName: event.name,
    registrationDate: registration.createdAt
  });
  
  // Send to analytics
  await trackEvent('registration_completed', {
    eventId: event.id,
    ticketType: registration.ticketType,
    revenue: registration.amount
  });
  
  // Notify team on Slack
  await sendSlackMessage(
    `New registration: ${attendee.name} for ${event.name}`
  );
}

async function handleCheckin(data) {
  const { attendee, event, checkInTime } = data;
  
  // Update real-time dashboard
  await updateDashboard(event.id, {
    checkedInCount: data.totalCheckedIn,
    lastCheckIn: checkInTime
  });
  
  // Send welcome notification
  await sendWelcomeNotification(attendee.email);
}

Implement idempotency in your webhook handlers. EcoEvents may send the same webhook multiple times for reliability.

Monitor Webhook Delivery

Track webhook delivery status in the dashboard:

View delivery logs
See success/failure rates
Retry failed webhooks
Monitor latency

Set up alerts for webhook failures in Settings > Notifications.

Calendar System Integrations

Sync events with popular calendar systems.

Google Calendar Integration

Connect your Google Calendar:

Navigate to Settings > Integrations > Calendar
Click Connect Google Calendar
Authorize EcoEvents access
Configure sync settings

interface CalendarSyncConfig {
  provider: 'google' | 'outlook' | 'apple';
  syncDirection: 'two-way' | 'ecoevents-to-calendar' | 'calendar-to-ecoevents';
  syncFrequency: 'real-time' | 'hourly' | 'daily';
  calendarId: string;
  includeAttendees: boolean;
  sendInvites: boolean;
  reminderSettings: {
    enabled: boolean;
    times: number[]; // minutes before event
  };
}

const googleCalendarConfig: CalendarSyncConfig = {
  provider: 'google',
  syncDirection: 'two-way',
  syncFrequency: 'real-time',
  calendarId: 'primary',
  includeAttendees: true,
  sendInvites: true,
  reminderSettings: {
    enabled: true,
    times: [1440, 60, 15] // 1 day, 1 hour, 15 minutes
  }
};

Features:

Automatic event creation in Google Calendar
Two-way sync for updates
Attendee list synchronization
Calendar invites with .ics files
Reminder configuration

Outlook/Microsoft 365 Integration

Similar setup for Microsoft calendars:

Click Connect Outlook
Sign in with Microsoft account
Grant necessary permissions
Configure sync settings

Supports both personal Outlook and Microsoft 365 business accounts.

Generate Calendar Links

Provide attendees with calendar links:

// Generate add-to-calendar links for all major platforms
const calendarLinks = {
  google: `https://calendar.google.com/calendar/render?action=TEMPLATE&text=${encodedEventName}&dates=${startDateTime}/${endDateTime}&details=${encodedDescription}&location=${encodedLocation}`,
  outlook: `https://outlook.live.com/calendar/0/deeplink/compose?subject=${encodedEventName}&startdt=${startDateTime}&enddt=${endDateTime}`,
  apple: `data:text/calendar;charset=utf8,${icsContent}`,
  yahoo: `https://calendar.yahoo.com/?v=60&view=d&type=20&title=${encodedEventName}&st=${startDateTime}&et=${endDateTime}`
};

// Or use EcoEvents API to generate links
const response = await fetch(
  `https://api.ecoevents.com/v1/events/${eventId}/calendar-links`,
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

Embed Calendar Widget

Add an “Add to Calendar” button to your event page:

<!-- EcoEvents calendar widget -->
<div class="ecoevents-calendar-widget" 
     data-event-id="event-123"
     data-theme="light">
</div>
<script src="https://cdn.ecoevents.com/widgets/calendar.js"></script>

The widget automatically generates links for all major calendar platforms.

Communication Platform Integrations

Slack Integration

Connect EcoEvents to your Slack workspace:

Navigate to Settings > Integrations > Slack
Click Add to Slack
Select workspace and channel
Configure notification preferences

const slackConfig = {
  workspace: 'your-workspace',
  defaultChannel: '#events',
  notifications: {
    newRegistration: {
      enabled: true,
      channel: '#registrations',
      message: '🎉 New registration: {{attendee.name}} for {{event.name}}'
    },
    eventPublished: {
      enabled: true,
      channel: '#events',
      message: '📅 Event published: {{event.name}} - {{event.registrationUrl}}'
    },
    milestones: {
      enabled: true,
      channel: '#events',
      thresholds: [25, 50, 75, 100], // percentage of capacity
      message: '🎯 {{event.name}} reached {{milestone}}% capacity!'
    },
    sustainability: {
      enabled: true,
      channel: '#sustainability',
      message: '♻️ Impact update: {{event.name}} is {{progress}}% toward carbon reduction goal'
    }
  },
  commands: {
    enabled: true,
    prefix: '/ecoevents'
  }
};

Use Slack commands like /ecoevents stats event-123 to get quick event statistics without leaving Slack.

Microsoft Teams Integration

Connect to Microsoft Teams:

Click Connect Microsoft Teams
Sign in and authorize
Select team and channel
Configure notifications

Features:

Adaptive cards for rich notifications
Direct links to event management
Team collaboration on event planning
Automated meeting creation for virtual events

Discord Integration

For community-focused events, connect Discord:

const discordConfig = {
  serverId: 'your-server-id',
  channels: {
    announcements: 'channel-id-1',
    registrations: 'channel-id-2',
    support: 'channel-id-3'
  },
  roles: {
    attendee: 'role-id-1',
    vip: 'role-id-2',
    speaker: 'role-id-3'
  },
  autoAssignRoles: true,
  welcomeMessage: 'Welcome {{attendee.name}}! You\'re registered for {{event.name}}'
};

Automatically assign roles to registered attendees and create dedicated event channels.

Email Marketing Platforms

Sync attendees with email marketing tools:Mailchimp Integration

const mailchimpConfig = {
  apiKey: 'your-api-key',
  listId: 'audience-id',
  syncSettings: {
    autoSync: true,
    syncFrequency: 'real-time',
    includeFields: ['name', 'email', 'company', 'ticketType'],
    createTags: true,
    tagPrefix: 'Event:'
  },
  campaigns: {
    autoCreateForEvent: true,
    templateId: 'template-123'
  }
};

SendGrid Integration

Sync contact lists
Trigger automated email campaigns
Track email engagement
A/B test event communications

Payment Processor Integrations

Stripe Integration

Connect Stripe for payment processing:

Navigate to Settings > Integrations > Payments
Click Connect Stripe
Sign in to Stripe or create account
Complete OAuth flow

interface StripeConfig {
  accountId: string;
  publicKey: string;
  webhookSecret: string;
  features: {
    paymentIntent: boolean;
    subscriptions: boolean;
    savePaymentMethods: boolean;
  };
  paymentMethods: Array<'card' | 'apple_pay' | 'google_pay' | 'ach'>;
  currency: string;
  statementDescriptor: string;
}

const stripeConfig: StripeConfig = {
  accountId: 'acct_xxx',
  publicKey: 'pk_live_xxx',
  webhookSecret: 'whsec_xxx',
  features: {
    paymentIntent: true,
    subscriptions: false,
    savePaymentMethods: true
  },
  paymentMethods: ['card', 'apple_pay', 'google_pay'],
  currency: 'usd',
  statementDescriptor: 'ECOEVENTS*'
};

Features:

Credit/debit card payments
Apple Pay and Google Pay
ACH bank transfers
Automatic refund processing
Payment analytics and reporting

PayPal Integration

Alternative payment processing:

Click Connect PayPal
Log in to PayPal business account
Grant permissions
Configure payment settings

Supports PayPal balance, credit cards through PayPal, and PayPal Credit.

Handle Payment Events

Process payment webhooks:

async function handlePaymentWebhook(event) {
  switch (event.type) {
    case 'payment.succeeded':
      await confirmRegistration(event.data.registrationId);
      await sendReceipt(event.data.attendeeEmail);
      await notifyOrganizer(event.data);
      break;
      
    case 'payment.failed':
      await notifyAttendee(event.data.attendeeEmail, 'payment_failed');
      await createRetryAttempt(event.data.paymentIntentId);
      break;
      
    case 'refund.processed':
      await cancelRegistration(event.data.registrationId);
      await sendRefundConfirmation(event.data.attendeeEmail);
      break;
  }
}

CRM and Analytics Integrations

Salesforce Integration

Sync attendees and events with Salesforce:

interface SalesforceMapping {
  attendeeToLead: {
    enabled: boolean;
    fieldMappings: Record<string, string>;
    autoConvert: boolean;
  };
  attendeeToContact: {
    enabled: boolean;
    fieldMappings: Record<string, string>;
  };
  eventToCampaign: {
    enabled: boolean;
    campaignType: string;
  };
  registrationToCampaignMember: {
    enabled: boolean;
    status: string;
  };
}

const salesforceMapping: SalesforceMapping = {
  attendeeToLead: {
    enabled: true,
    fieldMappings: {
      'name': 'Name',
      'email': 'Email',
      'company': 'Company',
      'phone': 'Phone',
      'event.name': 'LeadSource'
    },
    autoConvert: false
  },
  attendeeToContact: {
    enabled: true,
    fieldMappings: {
      'name': 'Name',
      'email': 'Email',
      'title': 'Title'
    }
  },
  eventToCampaign: {
    enabled: true,
    campaignType: 'Event'
  },
  registrationToCampaignMember: {
    enabled: true,
    status: 'Registered'
  }
};

HubSpot Integration

Connect with HubSpot CRM:

Create contacts from attendees
Track event registrations as deals
Log event attendance as activities
Trigger automated workflows
Sync to marketing lists

Google Analytics Integration

Track event page analytics:

<!-- Add to your event page -->
<script async src="https://www.googletagmanager.com/gtag/js?id=GA_MEASUREMENT_ID"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'GA_MEASUREMENT_ID');
  
  // Track event registration
  gtag('event', 'registration', {
    'event_id': '{{event.id}}',
    'event_name': '{{event.name}}',
    'ticket_type': '{{registration.ticketType}}',
    'value': {{registration.amount}},
    'currency': 'USD'
  });
</script>

Or use EcoEvents’ automatic GA4 integration in Settings > Integrations > Analytics.

Mixpanel Integration

Advanced event analytics:

// Automatically tracked events
const trackedEvents = [
  'Event Viewed',
  'Registration Started',
  'Registration Completed',
  'Ticket Selected',
  'Payment Completed',
  'Event Checked In',
  'Session Attended',
  'Sustainability Action Taken'
];

// Custom properties
const eventProperties = {
  eventId: 'event-123',
  eventName: 'Green Tech Summit',
  eventType: 'conference',
  ticketType: 'early-bird',
  sustainabilityScore: 85,
  carbonFootprint: 42
};

Sustainability Tool Integrations

Carbon Accounting Platforms

Export impact data to carbon accounting tools:

// Example: Export to carbon accounting API
const carbonData = {
  eventId: 'event-123',
  eventName: 'Green Tech Summit',
  startDate: '2026-06-15',
  endDate: '2026-06-17',
  emissions: {
    scope1: 0, // Direct emissions
    scope2: 3500, // Indirect from energy
    scope3: 39000, // Other indirect (travel, etc.)
    total: 42500
  },
  breakdown: {
    travel: 25000,
    venue: 8500,
    catering: 6000,
    waste: 2000,
    materials: 1000
  },
  offsetsPurchased: 42500,
  netEmissions: 0,
  methodology: 'GHG Protocol',
  verifiedBy: 'Third-Party Auditor'
};

await fetch('https://carbon-platform.com/api/v1/events', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(carbonData)
});

ESG Reporting Tools

Feed event sustainability data into ESG reporting:

Automatic data export to ESG platforms
Standardized reporting formats (GRI, SASB, TCFD)
Audit trail and verification documents
Integration with corporate sustainability dashboards

Offset Provider Integration

Connect with carbon offset providers:

interface OffsetProviderConfig {
  provider: 'goldstandard' | 'verra' | 'climateneutral' | 'custom';
  apiKey: string;
  projectPreferences: string[];
  autoOffsetRules: {
    enabled: boolean;
    threshold: number; // minimum kg CO2e to offset
    timing: 'immediate' | 'post-event';
  };
  certificateDelivery: 'email' | 'dashboard' | 'both';
}

Automatically purchase and distribute offset certificates to attendees.

Building Custom Integrations

Use the EcoEvents API

Build custom integrations with our REST API:

const EcoEventsAPI = {
  baseURL: 'https://api.ecoevents.com/v1',
  apiKey: 'your-api-key',

  async getEvent(eventId) {
    const response = await fetch(`${this.baseURL}/events/${eventId}`, {
      headers: { 'Authorization': `Bearer ${this.apiKey}` }
    });
    return response.json();
  },

  async listAttendees(eventId, filters = {}) {
    const params = new URLSearchParams(filters);
    const response = await fetch(
      `${this.baseURL}/events/${eventId}/attendees?${params}`,
      { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
    );
    return response.json();
  },

  async createRegistration(eventId, attendeeData) {
    const response = await fetch(
      `${this.baseURL}/events/${eventId}/registrations`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(attendeeData)
      }
    );
    return response.json();
  },

  async getImpactData(eventId) {
    const response = await fetch(
      `${this.baseURL}/events/${eventId}/impact`,
      { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
    );
    return response.json();
  }
};

See the complete API Reference for all available endpoints.

Generate API Keys

Create API keys in Settings > API:

Click Generate New Key
Name your key (e.g., “Production Integration”)
Select permissions/scopes
Copy and securely store the key
Set expiration date (optional)

API keys grant access to your account data. Store them securely and never commit them to version control.

Use Zapier for No-Code Integration

Connect EcoEvents to 5,000+ apps via Zapier:

Search for “EcoEvents” in Zapier
Choose a trigger (e.g., “New Registration”)
Connect your EcoEvents account
Select an action in another app
Configure and test your Zap

Popular Zap templates:

New Registration → Add to Google Sheets: Track registrations in spreadsheet
Event Published → Post to Twitter: Auto-announce new events
Check-in Completed → Send SMS: Welcome attendees via Twilio
Impact Report Generated → Save to Dropbox: Archive sustainability reports

Embed Widgets

Add EcoEvents functionality to your website:

<!-- Registration form widget -->
<div class="ecoevents-registration" 
     data-event-id="event-123"
     data-theme="light"
     data-show-sustainability="true">
</div>
<script src="https://cdn.ecoevents.com/widgets/registration.js"></script>

<!-- Impact dashboard widget -->
<div class="ecoevents-impact-widget"
     data-event-id="event-123"
     data-metrics="carbon,waste,travel"
     data-update-frequency="10000">
</div>
<script src="https://cdn.ecoevents.com/widgets/impact.js"></script>

<!-- Attendee counter widget -->
<div class="ecoevents-counter"
     data-event-id="event-123"
     data-style="progress-bar"
     data-show-capacity="true">
</div>
<script src="https://cdn.ecoevents.com/widgets/counter.js"></script>

Customize widget appearance with CSS or data attributes.

Integration Best Practices

Security

Use environment variables for API keys and secrets
Implement webhook signature verification
Use HTTPS for all API requests
Rotate API keys regularly
Follow principle of least privilege for permissions

Reliability

Implement retry logic with exponential backoff
Handle rate limits gracefully
Use idempotency keys for write operations
Log all integration errors
Set up monitoring and alerts

Performance

Cache frequently accessed data
Use pagination for large datasets
Batch operations when possible
Use webhooks instead of polling
Implement request queuing for high volume

Data Sync

Decide on sync direction (one-way or two-way)
Handle conflicts appropriately
Implement deduplication logic
Keep audit logs of sync operations
Test thoroughly before production use

Troubleshooting Common Issues

Webhook Not Receiving Events

Verify endpoint is publicly accessible
Check firewall and security group settings
Ensure you’re returning 200 status code
Verify SSL certificate is valid
Check webhook logs for delivery attempts

API Authentication Failing

Confirm API key is active and not expired
Check that key has required permissions
Verify Authorization header format: Bearer YOUR_KEY
Ensure account subscription includes API access

Calendar Sync Not Working

Re-authorize the calendar connection
Check that calendar permissions are granted
Verify time zone settings match
Ensure calendar isn’t at storage limit

Integration Rate Limited

Reduce request frequency
Implement exponential backoff
Consider upgrading to higher tier plan
Use webhooks instead of polling
Contact support for rate limit increase

Next Steps

Review the complete API Documentation
Explore webhook event reference
Check out the EcoEvents repository on GitHub
Contact integrations@ecoevents.com for enterprise integration support

​Overview

​Setting Up Webhooks

​Calendar System Integrations

​Communication Platform Integrations

​Payment Processor Integrations

​CRM and Analytics Integrations

​Sustainability Tool Integrations

​Building Custom Integrations

​Integration Best Practices

​Security

​Reliability

​Performance

​Data Sync

​Troubleshooting Common Issues

​Webhook Not Receiving Events

​API Authentication Failing

​Calendar Sync Not Working

​Integration Rate Limited

​Next Steps

Overview

Setting Up Webhooks

Calendar System Integrations

Communication Platform Integrations

Payment Processor Integrations

CRM and Analytics Integrations

Sustainability Tool Integrations

Building Custom Integrations

Integration Best Practices

Security

Reliability

Performance

Data Sync

Troubleshooting Common Issues

Webhook Not Receiving Events

API Authentication Failing

Calendar Sync Not Working

Integration Rate Limited

Next Steps