How to Integrate Replit with Sprout Social

1import os
2import requests
3from datetime import datetime, timedelta
4from typing import Optional
5
6ACCESS_TOKEN = os.environ["SPROUT_ACCESS_TOKEN"]
7BASE_URL = "https://api.sproutsocial.com/v1"
8
9HEADERS = {
10    "Authorization": f"Bearer {ACCESS_TOKEN}",
11    "Content-Type": "application/json"
12}
13
14def get_profiles() -> list:
15    """Get all customer profiles connected to the Sprout Social account."""
16    response = requests.get(f"{BASE_URL}/profile", headers=HEADERS)
17    response.raise_for_status()
18    data = response.json()
19    return data.get("data", {}).get("customer_profiles", [])
20
21def get_profile_analytics(profile_id: str, metrics: list,
22                          start_date: str, end_date: str) -> dict:
23    """
24    Get analytics for a specific profile.
25    metrics: list of metric names (e.g., ['impressions', 'engagements', 'followers_gained'])
26    Dates in YYYY-MM-DD format.
27    """
28    params = {
29        "start": f"{start_date}T00:00:00",
30        "end": f"{end_date}T23:59:59",
31        "fields": ",".join(metrics)
32    }
33    response = requests.get(
34        f"{BASE_URL}/metrics/customer/{profile_id}",
35        params=params,
36        headers=HEADERS
37    )
38    response.raise_for_status()
39    return response.json()
40
41def get_sent_posts(profile_ids: list, limit: int = 20) -> list:
42    """Retrieve recently published posts across specified profiles."""
43    params = {
44        "customer_profile_ids[]": profile_ids,
45        "count": limit,
46        "statuses[]": ["sent"]
47    }
48    response = requests.get(f"{BASE_URL}/message/", params=params, headers=HEADERS)
49    response.raise_for_status()
50    return response.json().get("data", {}).get("messages", [])
51
52def get_inbox_messages(profile_ids: list = None,
53                       status: str = "all", limit: int = 25) -> list:
54    """Fetch incoming messages from the Sprout Social inbox."""
55    params = {
56        "count": limit,
57        "status": status  # 'new', 'in_progress', 'completed', 'all'
58    }
59    if profile_ids:
60        params["customer_profile_ids[]"] = profile_ids
61
62    response = requests.get(f"{BASE_URL}/inbox/", params=params, headers=HEADERS)
63    response.raise_for_status()
64    return response.json().get("data", {}).get("messages", [])
65
66# Example usage
67if __name__ == "__main__":
68    profiles = get_profiles()
69    print(f"Connected profiles: {len(profiles)}")
70    for profile in profiles:
71        name = profile.get('name_for_display', 'Unknown')
72        network = profile.get('network_type', 'unknown')
73        profile_id = profile.get('customer_profile_id')
74        print(f"  {name} ({network}): ID {profile_id}")
75
76    if profiles:
77        end_date = datetime.now().strftime("%Y-%m-%d")
78        start_date = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
79        profile_id = profiles[0]['customer_profile_id']
80        print(f"\nFetching 7-day analytics for profile {profile_id}...")
81        analytics = get_profile_analytics(
82            profile_id,
83            ['impressions', 'engagements', 'followers_gained'],
84            start_date,
85            end_date
86        )
87        print(f"Analytics: {analytics}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const ACCESS_TOKEN = process.env.SPROUT_ACCESS_TOKEN;
8const BASE_URL = 'https://api.sproutsocial.com/v1';
9
10const sprout = axios.create({
11  baseURL: BASE_URL,
12  headers: {
13    'Authorization': `Bearer ${ACCESS_TOKEN}`,
14    'Content-Type': 'application/json'
15  }
16});
17
18// Get all connected profiles
19app.get('/profiles', async (req, res) => {
20  try {
21    const { data } = await sprout.get('/profile');
22    const profiles = data.data?.customer_profiles || [];
23    const simplified = profiles.map(p => ({
24      id: p.customer_profile_id,
25      name: p.name_for_display,
26      network: p.network_type
27    }));
28    res.json(simplified);
29  } catch (err) {
30    console.error('Profiles error:', err.response?.data || err.message);
31    res.status(500).json({ error: err.message });
32  }
33});
34
35// Publish a post immediately or scheduled
36app.post('/publish', async (req, res) => {
37  const { profileIds, message, imageUrl, scheduledAt } = req.body;
38  if (!profileIds || !message) {
39    return res.status(400).json({ error: 'profileIds and message are required' });
40  }
41
42  try {
43    const payload = {
44      customer_profile_ids: Array.isArray(profileIds) ? profileIds : [profileIds],
45      message_content: [
46        {
47          type: 'text',
48          text: message
49        }
50      ]
51    };
52
53    if (imageUrl) {
54      payload.message_content.push({
55        type: 'image',
56        url: imageUrl
57      });
58    }
59
60    if (scheduledAt) {
61      // scheduledAt should be ISO 8601: 2025-04-01T14:00:00Z
62      payload.scheduled_send_time = scheduledAt;
63    }
64
65    const { data } = await sprout.post('/message/', payload);
66    const messageId = data.data?.id;
67    res.json({ success: true, messageId, scheduled: !!scheduledAt });
68  } catch (err) {
69    console.error('Publish error:', err.response?.data || err.message);
70    res.status(500).json({ error: err.message, detail: err.response?.data });
71  }
72});
73
74// Get analytics for a profile
75app.get('/analytics/:profileId', async (req, res) => {
76  const { start, end } = req.query;
77  const endDate = end || new Date().toISOString().split('T')[0];
78  const startDate = start || new Date(Date.now() - 7 * 86400000).toISOString().split('T')[0];
79
80  try {
81    const { data } = await sprout.get(
82      `/metrics/customer/${req.params.profileId}`,
83      {
84        params: {
85          start: `${startDate}T00:00:00`,
86          end: `${endDate}T23:59:59`,
87          fields: 'impressions,engagements,followers_gained'
88        }
89      }
90    );
91    res.json(data);
92  } catch (err) {
93    console.error('Analytics error:', err.response?.data || err.message);
94    res.status(500).json({ error: err.message });
95  }
96});
97
98app.get('/health', (req, res) => res.json({ status: 'ok' }));
99
100app.listen(3000, '0.0.0.0', () => {
101  console.log('Sprout Social integration server running on port 3000');
102});

1from flask import Flask, request, jsonify
2import os
3import hmac
4import hashlib
5
6app = Flask(__name__)
7WEBHOOK_SECRET = os.environ.get("SPROUT_WEBHOOK_SECRET", "")
8
9def verify_sprout_signature(payload: bytes, signature: str) -> bool:
10    """Verify the Sprout Social webhook signature."""
11    if not WEBHOOK_SECRET or not signature:
12        return True  # Skip if no secret configured
13    expected = hmac.new(
14        WEBHOOK_SECRET.encode(),
15        payload,
16        hashlib.sha256
17    ).hexdigest()
18    return hmac.compare_digest(f"sha256={expected}", signature)
19
20@app.route('/sprout/webhook', methods=['POST'])
21def sprout_webhook():
22    signature = request.headers.get('X-Sprout-Signature', '')
23    if not verify_sprout_signature(request.data, signature):
24        return jsonify({'error': 'Invalid signature'}), 403
25
26    data = request.get_json(force=True)
27    if not data:
28        return jsonify({'error': 'No data'}), 400
29
30    event_type = data.get('event_type', 'unknown')
31    print(f"Sprout webhook: {event_type}")
32
33    if event_type == 'message.inbound.new':
34        message = data.get('message', {})
35        sender = message.get('sender', {}).get('name', 'Anonymous')
36        network = message.get('network_type', 'unknown')
37        text = message.get('text', '')
38        print(f"New message from {sender} on {network}: {text[:100]}")
39        # Route to CRM, create support ticket, notify team
40
41    elif event_type == 'message.sent':
42        message = data.get('message', {})
43        print(f"Post published: {message.get('id')}")
44
45    return jsonify({'status': 'received'}), 200
46
47@app.route('/health', methods=['GET'])
48def health():
49    return jsonify({'status': 'ok'}), 200
50
51if __name__ == '__main__':
52    app.run(host='0.0.0.0', port=3000)