How to Integrate Replit with SharpSpring

1// check-sharpspring-secrets.js
2const required = ['SHARPSPRING_ACCOUNT_ID', 'SHARPSPRING_SECRET_KEY'];
3for (const key of required) {
4  if (!process.env[key]) {
5    throw new Error(`Missing: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
6  }
7}
8console.log('SharpSpring credentials configured.');
9console.log('Account ID:', process.env.SHARPSPRING_ACCOUNT_ID);
10console.log('Secret Key prefix:', process.env.SHARPSPRING_SECRET_KEY.slice(0, 8) + '...');

1// sharpspring-client.js — SharpSpring REST API client for Replit
2const ACCOUNT_ID = process.env.SHARPSPRING_ACCOUNT_ID;
3const SECRET_KEY = process.env.SHARPSPRING_SECRET_KEY;
4const BASE_URL = `https://api.sharpspring.com/pubapi/v1/?accountID=${ACCOUNT_ID}&secretKey=${SECRET_KEY}`;
5
6let requestId = 1;
7
8async function sharpSpringRequest(method, params = {}) {
9  const body = {
10    method,
11    params,
12    id: `req_${requestId++}` // Unique request ID
13  };
14
15  const response = await fetch(BASE_URL, {
16    method: 'POST',
17    headers: { 'Content-Type': 'application/json' },
18    body: JSON.stringify(body)
19  });
20
21  if (!response.ok) {
22    throw new Error(`HTTP error: ${response.status}`);
23  }
24
25  const data = await response.json();
26
27  // SharpSpring returns errors in the body even on HTTP 200
28  if (data.error) {
29    throw new Error(`SharpSpring error: ${JSON.stringify(data.error)}`);
30  }
31
32  return data.result;
33}
34
35// --- LEADS ---
36
37async function getLeads(where = {}, limit = 100, offset = 0) {
38  const result = await sharpSpringRequest('getLeads', { where, limit, offset });
39  return result?.lead || [];
40}
41
42async function createLead(leadData) {
43  const result = await sharpSpringRequest('createLeads', {
44    objects: [leadData] // SharpSpring uses array for batch creates
45  });
46  return result?.creates?.[0];
47}
48
49async function updateLead(leadId, updates) {
50  const result = await sharpSpringRequest('updateLeads', {
51    objects: [{ id: leadId, ...updates }]
52  });
53  return result?.updates?.[0];
54}
55
56// --- OPPORTUNITIES ---
57
58async function createOpportunity(oppData) {
59  const result = await sharpSpringRequest('createOpportunities', {
60    objects: [oppData]
61  });
62  return result?.creates?.[0];
63}
64
65// --- LISTS ---
66
67async function getLists() {
68  const result = await sharpSpringRequest('getActiveLists', {});
69  return result?.list || [];
70}
71
72async function addLeadToList(leadId, listId) {
73  return sharpSpringRequest('createListMemberships', {
74    objects: [{ leadID: leadId, listID: listId }]
75  });
76}
77
78// Example: create a lead
79(async () => {
80  try {
81    const lead = await createLead({
82      emailAddress: 'contact@example.com',
83      firstName: 'Jane',
84      lastName: 'Smith',
85      companyName: 'Acme Corp',
86      phone: '555-123-4567',
87      leadScore: 50
88    });
89    console.log('Lead created:', lead);
90
91    // Get available lists
92    const lists = await getLists();
93    console.log(`Available lists: ${lists.length}`);
94    lists.slice(0, 3).forEach(l => console.log(` - ${l.name} (ID: ${l.id})`));
95  } catch (err) {
96    console.error('Error:', err.message);
97  }
98})();
99
100module.exports = { sharpSpringRequest, getLeads, createLead, updateLead, createOpportunity, getLists, addLeadToList };

1# sharpspring_client.py — SharpSpring API client for Replit (Python)
2import os
3import requests
4
5ACCOUNT_ID = os.environ['SHARPSPRING_ACCOUNT_ID']
6SECRET_KEY = os.environ['SHARPSPRING_SECRET_KEY']
7BASE_URL = f'https://api.sharpspring.com/pubapi/v1/?accountID={ACCOUNT_ID}&secretKey={SECRET_KEY}'
8
9_request_counter = 0
10
11def ss_request(method: str, params: dict = None) -> dict:
12    """Make a SharpSpring API request."""
13    global _request_counter
14    _request_counter += 1
15
16    body = {
17        'method': method,
18        'params': params or {},
19        'id': f'req_{_request_counter}'
20    }
21
22    response = requests.post(BASE_URL, json=body)
23    response.raise_for_status()
24    data = response.json()
25
26    if data.get('error'):
27        raise Exception(f'SharpSpring API error: {data["error"]}')
28
29    return data.get('result', {})
30
31def get_leads(where: dict = None, limit: int = 100, offset: int = 0) -> list:
32    """Fetch leads with optional filtering."""
33    result = ss_request('getLeads', {
34        'where': where or {},
35        'limit': limit,
36        'offset': offset
37    })
38    return result.get('lead', [])
39
40def create_lead(email: str, first_name: str, last_name: str,
41               company: str = None, phone: str = None, **custom_fields) -> dict:
42    """Create a new lead in SharpSpring."""
43    lead_data = {
44        'emailAddress': email,
45        'firstName': first_name,
46        'lastName': last_name
47    }
48    if company: lead_data['companyName'] = company
49    if phone: lead_data['phone'] = phone
50    lead_data.update(custom_fields)
51
52    result = ss_request('createLeads', {'objects': [lead_data]})
53    return result.get('creates', [{}])[0]
54
55def update_lead(lead_id: str, updates: dict) -> dict:
56    """Update a lead by ID."""
57    updates['id'] = lead_id
58    result = ss_request('updateLeads', {'objects': [updates]})
59    return result.get('updates', [{}])[0]
60
61def create_opportunity(contact_id: str, name: str, value: float,
62                       pipeline_stage: str, close_date: str) -> dict:
63    """Create an opportunity linked to a contact."""
64    result = ss_request('createOpportunities', {
65        'objects': [{
66            'contactID': contact_id,
67            'oppName': name,
68            'oppValue': value,
69            'pipelineStage': pipeline_stage,
70            'closeDate': close_date  # YYYY-MM-DD
71        }]
72    })
73    return result.get('creates', [{}])[0]
74
75def add_to_list(lead_id: str, list_id: str) -> dict:
76    """Add a lead to a SharpSpring list."""
77    return ss_request('createListMemberships', {
78        'objects': [{'leadID': lead_id, 'listID': list_id}]
79    })
80
81if __name__ == '__main__':
82    # Create a test lead
83    result = create_lead(
84        email='test@example.com',
85        first_name='Test',
86        last_name='User',
87        company='Test Company'
88    )
89    print('Lead created:', result)

1// sharpspring-server.js — Express server for SharpSpring API proxy and webhooks
2const express = require('express');
3const { createLead, getLeads, addLeadToList } = require('./sharpspring-client');
4const app = express();
5app.use(express.json());
6
7// POST /leads — create a lead from external form or service
8app.post('/leads', async (req, res) => {
9  try {
10    const { email, firstName, lastName, company, phone, listId } = req.body;
11    if (!email || !firstName || !lastName) {
12      return res.status(400).json({ error: 'email, firstName, and lastName are required' });
13    }
14
15    const lead = await createLead({
16      emailAddress: email,
17      firstName,
18      lastName,
19      companyName: company,
20      phone,
21      leadSource: 'API Import'
22    });
23
24    // If a list ID is provided, add the lead to the list
25    if (listId && lead?.id) {
26      await addLeadToList(lead.id, listId);
27    }
28
29    res.status(201).json({ success: true, leadId: lead?.id });
30  } catch (err) {
31    console.error('Create lead error:', err.message);
32    res.status(500).json({ error: err.message });
33  }
34});
35
36// GET /leads — query leads with optional filters
37app.get('/leads', async (req, res) => {
38  try {
39    const where = {};
40    if (req.query.email) where.emailAddress = req.query.email;
41    const leads = await getLeads(where, parseInt(req.query.limit) || 50);
42    res.json(leads);
43  } catch (err) {
44    res.status(500).json({ error: err.message });
45  }
46});
47
48// POST /webhook/sharpspring — receive SharpSpring event notifications
49app.post('/webhook/sharpspring', (req, res) => {
50  // Acknowledge immediately before processing
51  res.status(200).json({ received: true });
52
53  // Process asynchronously
54  setImmediate(() => {
55    const events = Array.isArray(req.body) ? req.body : [req.body];
56    for (const event of events) {
57      const eventType = event.type || event.eventType;
58      const lead = event.lead || event.data;
59      console.log(`SharpSpring event: ${eventType}`, lead?.emailAddress || '');
60
61      if (eventType === 'formSubmit' || eventType === 'form_submit') {
62        console.log('Form submitted by:', lead?.emailAddress, '— Form:', event.formName);
63        // TODO: trigger additional actions (Slack notify, CRM update, etc.)
64      } else if (eventType === 'emailOpen') {
65        console.log('Email opened by:', lead?.emailAddress);
66      } else if (eventType === 'leadScoreChange') {
67        console.log(`Lead score changed: ${event.oldScore} → ${event.newScore}`);
68      }
69    }
70  });
71});
72
73app.listen(3000, '0.0.0.0', () => {
74  console.log('SharpSpring integration server running on port 3000');
75});