# How to Integrate Retool with Sendible

- Tool: Retool
- Difficulty: Beginner
- Time required: 20 minutes
- Last updated: April 2026

## TL;DR

Connect Retool to Sendible by creating a REST API Resource with Sendible's API base URL and API key authentication. Use Sendible's REST API to build agency social media management panels that monitor client accounts, view post schedules, track engagement metrics, and generate client reports — giving your agency team direct access to multi-client social data without switching between Sendible's interface and your reporting tools.

## Build a Sendible Agency Social Media Management Panel in Retool

Sendible is built specifically for social media agencies managing multiple client accounts simultaneously. While Sendible's own dashboard provides solid account management, agencies often need to combine Sendible's social data with their own client CRM records, billing systems, or project management tools — creating a unified ops view that Sendible's interface doesn't provide out of the box.

Retool solves this by giving your agency team direct query access to Sendible's REST API. You can build panels that show all client accounts with their posting activity this week, which client's scheduled queue is running low, which posts are getting the highest engagement, and whether team members are hitting their content publishing targets. Combined with your internal database or CRM, you can track which clients are on which service tier alongside their actual social performance.

Sendible's API uses API key authentication with keys generated in your Sendible account settings. Retool's server-side proxy keeps credentials secure. The most valuable agency workflows — service (account) management, post scheduling status, engagement analytics, and team activity — are all accessible through Sendible's REST API.

## Before you start

- A Sendible agency account with API access (API access is available on Traction and White Label plans)
- A Sendible API key (Settings → API → Generate API Key)
- A Retool account with permission to create Resources
- At least one client service (connected social account) configured in Sendible
- Familiarity with Retool's query editor and basic Table component configuration

## Step-by-step guide

### 1. Create a Sendible REST API Resource

Navigate to the Resources tab in your Retool instance and click Add Resource. Scroll through the resource type options and select REST API. Name the resource 'Sendible API' to keep it clearly labeled.

In the Base URL field, enter https://api.sendible.com/api/v1. This is Sendible's REST API v1 base URL — all endpoint paths will be appended to this base. Ensure there is no trailing slash.

Sendible authenticates API requests using an API key passed as a header. In the Headers section of the resource configuration, click Add Header. Set the header name to Authorization and the value to your Sendible API key — check Sendible's current API documentation for whether the key should be passed as 'Bearer {key}' or a raw key value, as authentication formats can vary by API version.

Alternatively, Sendible may accept the API key as a URL parameter. Add it as a URL parameter with key name api_key if the header approach doesn't work. Test both in Retool's query preview panel to confirm which method your account requires.

For better security, store the API key as a configuration variable. Go to Retool's Settings → Configuration Variables, create a variable named SENDIBLE_API_KEY, mark it as Secret, and reference it in the header value as {{ retoolContext.configVars.SENDIBLE_API_KEY }}.

Leave all other settings at their defaults and click Save Changes.

**Expected result:** The Sendible API REST resource is saved in Retool with authentication headers configured and is available for queries across all apps in your workspace.

### 2. Retrieve client services and account information

Create your first query to list all Sendible services (connected client social accounts) in your agency account. In your Retool app, open the Code panel and click + to add a query. Name it getServices and select the Sendible API resource.

Set the Method to GET. In the Path field, enter /services. This endpoint returns all services (social account connections) accessible with your API credentials. Each service object includes a service_id, name, profile_type (the social network: twitter, facebook, instagram, linkedin, etc.), profile_name (the social account username or page name), and status.

Add a URL parameter:
- limit: 100 (to retrieve up to 100 services in a single call)

Set getServices to run on page load so the client list is always populated when the dashboard loads. Bind the results to a Select or Dropdown component named dropdown_service with options formatted as:
{{ getServices.data.data.map(s => ({ label: `${s.name} (${s.profile_type})`, value: s.service_id })) }}

Also bind the full service list to a Table component that serves as the main client overview. Add columns for service name, social platform type, profile name, and status. This gives your account managers a quick overview of all managed social accounts across all clients.

If your agency has organized services into groups by client, check if the Sendible API supports a groups or clients endpoint to retrieve the higher-level client organization structure.

```
// JavaScript transformer — format services list for agency overview table
const services = (data.data || []);
return services.map(service => ({
  service_id: service.service_id || service.id,
  client_name: service.name || 'Unknown Client',
  platform: service.profile_type
    ? service.profile_type.charAt(0).toUpperCase() + service.profile_type.slice(1)
    : 'Unknown',
  account_name: service.profile_name || service.username || 'N/A',
  status: service.status || 'active',
  is_active: service.status !== 'inactive'
})).sort((a, b) => a.client_name.localeCompare(b.client_name));
```

**Expected result:** The services query returns all connected social accounts. The transformer formats them into a clean list showing client name, platform type, and account name. The dropdown and table both populate with all agency client accounts.

### 3. Query scheduled posts and content queue

Create queries to retrieve scheduled posts for selected client services. This powers the scheduling status view that helps managers identify which clients have low content queues.

Create a query named getScheduledPosts:
- Method: GET
- Path: /messages
- URL parameters:
  - service_id: {{ dropdown_service.value }}
  - status: pending (to retrieve only scheduled, not yet published posts)
  - from: {{ new Date().toISOString().split('T')[0] }} (today's date)
  - to: {{ new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0] }} (7 days from now)
  - limit: 50

This returns pending posts for the selected service scheduled in the next 7 days. Each message object includes a message_id, message (the post text), scheduled_at (scheduled publish time), status, and the service it belongs to.

For the all-clients queue status view (the most useful agency dashboard), create a JavaScript query named getQueueStatusAllClients that iterates through all service IDs and counts scheduled posts:

Bind this queue status data to a Table with columns for client name, platform, posts scheduled this week, and a traffic light status (green = 7+ posts, yellow = 3-6, red = 0-2). Apply conditional row formatting to highlight the red-status rows so account managers immediately see which clients need content attention.

```
// JavaScript transformer — summarize scheduled posts per service
const posts = (data.data || []);
const serviceId = dropdown_service.value;

return {
  service_id: serviceId,
  scheduled_count: posts.length,
  posts: posts.map(post => ({
    id: post.message_id || post.id,
    content_preview: (post.message || post.content || '').substring(0, 100) + '...',
    scheduled_at: post.scheduled_at
      ? new Date(post.scheduled_at).toLocaleString('en-US', {
          month: 'short', day: 'numeric',
          hour: '2-digit', minute: '2-digit'
        })
      : 'Not scheduled',
    status: post.status || 'pending',
    has_media: !!(post.media && post.media.length > 0)
  })).sort((a, b) => new Date(a.scheduled_at) - new Date(b.scheduled_at))
};
```

**Expected result:** The scheduled posts query returns upcoming posts for the selected service. The queue status table shows all client services with their scheduled post count and color-coded status indicators.

### 4. Fetch engagement analytics and post performance

Create queries to retrieve post performance data for published content. Sendible's API provides analytics for published posts including likes, comments, shares, and reach metrics.

Create a query named getPublishedPosts:
- Method: GET
- Path: /messages
- URL parameters:
  - service_id: {{ dropdown_service.value }}
  - status: sent (published posts)
  - from: {{ dateRangePicker.startDate }}
  - to: {{ dateRangePicker.endDate }}
  - limit: 100

For post-level engagement metrics, create getPostAnalytics:
- Method: GET
- Path: /messages/{{ table_posts.selectedRow.id }}/analytics

This returns engagement data for a specific selected post. Bind the published posts to a Table named table_posts. When a row is selected, getPostAnalytics automatically fetches engagement data for that post.

For the aggregate analytics view (total reach, total engagement across all posts in a period), create a JavaScript query named aggregateEngagement that processes the getPublishedPosts results:

Add a Row of Stat components at the top of your dashboard: Total Posts Published, Total Likes, Total Comments, Average Engagement Rate. Below, show the full posts table with inline engagement columns. Add a Chart component showing engagement per post date as a line chart to identify high-performing content days.

For an agency-wide view, add a second Table that shows aggregate performance per client service — which client's accounts are getting the best engagement rates — enabling data-driven conversations with clients about content strategy.

```
// JavaScript query — aggregate engagement metrics from published posts
const posts = (getPublishedPosts.data?.data || []);

const metrics = posts.reduce((acc, post) => {
  const likes = parseInt(post.likes || post.reactions || 0);
  const comments = parseInt(post.comments || 0);
  const shares = parseInt(post.shares || post.retweets || 0);
  const reach = parseInt(post.reach || post.impressions || 0);
  const engagement = likes + comments + shares;

  return {
    total_posts: acc.total_posts + 1,
    total_likes: acc.total_likes + likes,
    total_comments: acc.total_comments + comments,
    total_shares: acc.total_shares + shares,
    total_reach: acc.total_reach + reach,
    total_engagement: acc.total_engagement + engagement
  };
}, { total_posts: 0, total_likes: 0, total_comments: 0, total_shares: 0, total_reach: 0, total_engagement: 0 });

const engagementRate = metrics.total_reach > 0
  ? ((metrics.total_engagement / metrics.total_reach) * 100).toFixed(2) + '%'
  : 'N/A';

return {
  ...metrics,
  engagement_rate: engagementRate,
  avg_likes_per_post: metrics.total_posts > 0
    ? (metrics.total_likes / metrics.total_posts).toFixed(1)
    : '0'
};
```

**Expected result:** The published posts table populates with recent content for the selected client service. Stat components show aggregate totals. The Chart displays engagement trends over the selected date range.

### 5. Build client report generation panel

Create a client-ready reporting panel that generates a structured performance summary for any selected client service over a chosen time period. This replaces manual report compilation from Sendible's built-in reports.

Create a query named getClientReportData that combines: getPublishedPosts results, aggregated engagement metrics, best-performing post (highest engagement), and top content type (image, video, text) breakdown.

In your Retool app, add:
- A client selector dropdown (reuse dropdown_service)
- A Date Range Picker for the report period
- A 'Generate Report' button that triggers all report queries
- A Report Preview section with:
  - Client name and reporting period header
  - Key metrics row (posts published, total reach, avg engagement rate)
  - Best performing post card with content preview and metrics
  - Platform breakdown table if the client has multiple services
  - Week-over-week comparison if previous period data is available

For sharing, Retool's Share feature allows you to generate a view-only link to the dashboard that clients can access without a Retool login. Set the share settings to restrict editing while allowing read-only access.

For agencies managing 20+ clients who need automated monthly reports, a Retool Workflow on a monthly schedule can generate and email report data by combining Sendible API calls with Sendible email or another email service resource. For complex multi-client reporting pipelines with white-label client portals, RapidDev's team can help build a comprehensive agency operations platform on top of Retool.

```
// JavaScript query — build structured client report object
const service = getServices.data?.data?.find(
  s => (s.service_id || s.id) === dropdown_service.value
) || {};

const metrics = aggregateEngagement.data || {};
const posts = (getPublishedPosts.data?.data || []);

// Find best performing post by total engagement
const bestPost = posts.reduce((best, post) => {
  const engagement = parseInt(post.likes || 0) + parseInt(post.comments || 0) + parseInt(post.shares || 0);
  const bestEngagement = parseInt(best.likes || 0) + parseInt(best.comments || 0) + parseInt(best.shares || 0);
  return engagement > bestEngagement ? post : best;
}, posts[0] || {});

return {
  client_name: service.name || 'Unknown Client',
  platform: service.profile_type || 'Unknown',
  account: service.profile_name || service.username || 'N/A',
  report_period: {
    from: dateRangePicker.startDate,
    to: dateRangePicker.endDate
  },
  summary: {
    posts_published: metrics.total_posts || 0,
    total_reach: (metrics.total_reach || 0).toLocaleString(),
    total_engagement: (metrics.total_engagement || 0).toLocaleString(),
    engagement_rate: metrics.engagement_rate || 'N/A',
    avg_likes_per_post: metrics.avg_likes_per_post || '0'
  },
  best_post: {
    content: (bestPost.message || bestPost.content || '').substring(0, 200),
    published_at: bestPost.published_at || bestPost.sent_at || 'N/A',
    likes: bestPost.likes || 0,
    comments: bestPost.comments || 0
  }
};
```

**Expected result:** The client report panel shows a structured performance summary for the selected client and date range. All key metrics are displayed in a shareable format that account managers can present directly to clients.

## Best practices

- Store your Sendible API key as a Secret configuration variable in Retool's Settings → Configuration Variables — never paste it directly into resource headers.
- Set getServices to run on page load so the client account selector is always populated. Set analytics and post queries to run on manual trigger to avoid unnecessary API calls when managers are browsing the dashboard.
- Add a date range picker to all analytics queries so account managers can quickly switch between weekly, monthly, and quarterly views for client reporting.
- Group Sendible services by client in your database (create a mapping table) so you can display client-level aggregate metrics even when one client has multiple social accounts across platforms.
- Use conditional Table row formatting (green/yellow/red) for scheduling queue status — this visual triage helps account managers prioritize which client accounts need content attention without reading numbers.
- Cache weekly analytics data in Retool Database via a Retool Workflow to enable historical trend comparisons without consuming Sendible API quota on every dashboard load.
- Share your Retool dashboard in read-only mode with senior account managers and client success leads so they can monitor client performance without needing Retool editing permissions.

## Use cases

### Build a multi-client scheduling status dashboard

Create a Retool panel that shows all Sendible client accounts (services) with their scheduled post counts for the upcoming week. Highlight clients with fewer than 5 posts scheduled (low queue warning) and clients with no posts scheduled at all. Provide a quick-action link to open each client's Sendible scheduling queue for team members to fill gaps.

Prompt example:

```
Build a client scheduling overview panel that queries all Sendible services, shows each client's scheduled post count for the next 7 days, highlights accounts with low queues in orange and empty queues in red, and includes a button to open the Sendible post scheduler for the selected client.
```

### Agency engagement performance tracker by client

Build a Retool dashboard for your account managers that compares engagement performance across all client accounts over a selected time period. Show total posts published, average likes, average comments, and total reach per client account. Sort by engagement rate to identify which clients are getting the best results and which need content strategy adjustments.

Prompt example:

```
Create a client performance dashboard that fetches post analytics for all Sendible services over the past 30 days, calculates average engagement rate per client, displays a ranked table from highest to lowest performer, and shows a Chart comparing total reach across clients.
```

### Team content publishing activity tracker

Build an operational panel for agency managers that shows which team members have published or scheduled posts in the past week, broken down by client. Show each team member's post count, which clients they worked on, and whether they met their weekly content targets. This gives managers visibility into team workload distribution without requiring manual timesheet review.

Prompt example:

```
Build a team activity dashboard that queries recent posts by user from Sendible, shows each team member's post count by client for the past week in a Table, highlights team members below their target post count, and provides a drilldown view of individual posts created by a selected team member.
```

## Troubleshooting

### API returns 401 Unauthorized despite using the correct API key

Cause: Sendible's API key authentication format may require a specific header name or format. The API key may need to be passed as a Bearer token, a custom header, or a URL parameter depending on the API version.

Solution: Check Sendible's developer documentation at developers.sendible.com for the current authentication header format. Try both 'Authorization: Bearer {key}' and 'Authorization: {key}'. If neither works, try passing the key as a URL parameter with key name 'api_key'. Confirm API access is enabled for your Sendible plan in your account settings.

### Messages query returns empty results even though posts are scheduled in Sendible

Cause: The status filter may not match the correct value, or the date range parameters may be incorrectly formatted for Sendible's API.

Solution: Try removing the status filter to retrieve all messages regardless of status, then check what status values appear in the response. Sendible may use different status values than 'pending' or 'sent'. Also verify that date parameters are in the format expected by the API — test with a broad date range (from 30 days ago to 30 days ahead) to confirm data is returning before adding specific filters.

### Analytics data for published posts returns zeros or empty fields

Cause: Engagement analytics may only be available for posts published more than 24-48 hours ago, as Sendible pulls analytics from social platforms on a delay. Very recent posts may not have analytics populated yet.

Solution: Set your date range filter to start at least 48 hours in the past to ensure analytics have had time to populate. Also check whether your Sendible plan includes analytics features — analytics reporting may require a higher-tier plan. Verify the analytics endpoint path matches Sendible's current API documentation.

## Frequently asked questions

### Does Sendible have a native connector in Retool?

No, Sendible does not have a native connector in Retool. You connect it via a REST API Resource using your Sendible API key for authentication. The integration covers key agency workflows — retrieving client services, scheduled posts, published content, and engagement metrics — all accessible through Sendible's REST API.

### Which Sendible plan do I need for API access?

API access is available on Sendible's Traction plan and above. It is not available on the Creator plan. If you're on a White Label plan, you may have custom API endpoint configurations. Check your Sendible account settings under Settings → API to verify whether your plan includes API access and to generate your API key.

### Can I create and schedule posts in Sendible from Retool?

Yes, Sendible's API supports creating new posts via POST requests to the /messages endpoint with the post content, scheduled time, and target service ID. You can build a Retool form where your social media team writes post content, selects the client account and scheduled date, and submits — which then creates a scheduled post in Sendible. This creates a custom content workflow without requiring team members to use Sendible's interface directly.

### How do I handle multiple social platforms for the same client in Retool?

Each Sendible service represents one social account connection (one service = one platform account). A client with Twitter, Facebook, and LinkedIn accounts will have three separate services in Sendible. In Retool, build a multi-select component that allows selecting multiple services, then aggregate their metrics in a JavaScript query. Alternatively, create a client-service mapping table in your database to group services by client name for aggregate reporting.

### Can I use Retool Workflows to automate social media reporting for clients?

Yes. Create a Retool Workflow with a Schedule trigger that runs on the first day of each month. The workflow queries Sendible for all services, fetches the previous month's published posts and analytics, aggregates the data per client, and stores the results in Retool Database or sends a formatted report via email using SendGrid or another email resource. This automates monthly client reporting without any manual work from your team.

---

Source: https://www.rapidevelopers.com/retool-integrations/sendible
© RapidDev — https://www.rapidevelopers.com/retool-integrations/sendible