How to Integrate Retool with Amplitude

Navigate to the Resources tab in Retool and click Add Resource. Select REST API from the list. Name it 'Amplitude Analytics API'. In the Base URL field, enter https://amplitude.com/api. This is Amplitude's REST API base — individual endpoints append their version and path to this base (e.g., /2/events/segmentation). For authentication, select Basic Auth from the Authentication dropdown. Amplitude uses HTTP Basic authentication where the username is your API key and the password is your secret key. Enter your API key in the Username field and your secret key in the Password field. For better security, store these as configuration variables first. Navigate to Settings → Configuration Variables, create AMPLITUDE_API_KEY and AMPLITUDE_SECRET_KEY, mark both as Secret, and use {{ retoolContext.configVars.AMPLITUDE_API_KEY }} and {{ retoolContext.configVars.AMPLITUDE_SECRET_KEY }} in the resource's authentication fields. Note: Amplitude has separate API endpoints for different regions. If your Amplitude organization uses the EU data center, use https://analytics.eu.amplitude.com/api instead of the standard URL. Click Save Changes.

Create a query to pull event segmentation data — this is Amplitude's core analytics query type, showing event counts filtered by date range and user properties. Name the query getEventSegmentation. Set Method to GET, Path to /2/events/segmentation. Amplitude's segmentation endpoint accepts URL parameters for the query definition. The key parameters are: - e: JSON-encoded event definition (event name and optional filter) - start: start date (YYYYMMDD format) - end: end date (YYYYMMDD format) - i: interval (1 for daily, 7 for weekly, 30 for monthly) - s: optional segmentation property filters Add URL parameters to your query: - e: { "event_type": "{{ dropdown_eventName.value || 'any' }}" } (URL-encoded) - start: {{ moment(dateRange.value[0]).format('YYYYMMDD') }} - end: {{ moment(dateRange.value[1]).format('YYYYMMDD') }} - i: {{ dropdown_interval.value || '1' }} Amplitude returns a data object with series (array of arrays with counts) and seriesLabels (event names), plus xValues (date labels for each data point). This format requires a transformer before it's usable in Retool Charts.

1// JavaScript transformer — convert Amplitude segmentation to Chart-friendly format
2const result = data?.data || {};
3const xValues = result.xValues || [];
4const series = result.series || [[]];
5const labels = result.seriesLabels || ['Event Count'];
6
7// Convert to array of {date, value} objects for Retool Chart
8const chartData = xValues.map((date, index) => {
9  const point = { date };
10  series.forEach((seriesData, seriesIndex) => {
11    const label = labels[seriesIndex] || `Series ${seriesIndex + 1}`;
12    point[label] = seriesData[index] || 0;
13  });
14  return point;
15});
16
17return {
18  chart_data: chartData,
19  total: series[0].reduce((sum, val) => sum + (val || 0), 0),
20  dates: xValues,
21  values: series[0] || []
22};

Create a query to retrieve individual user event history. This is valuable for support investigations where you want to see exactly what a specific user did. Name the query getUserActivity. Set Method to GET, Path to /2/useractivity. Required URL parameters: - user: the Amplitude user ID or device ID you're looking up - limit: number of events to return (max 1000, default 100) Optional parameters: - start: start timestamp (seconds since epoch) - end: end timestamp Amplitude's user activity endpoint returns an array of events in the userData field. Each event has event_type, event_time, event_properties, user_properties, and metadata about the device and location. Add a Text Input named textInput_userId to your Retool app. Set getUserActivity to trigger on the Search button click, using {{ textInput_userId.value }} as the user parameter value. Bind the results to a Table component. The transformer should flatten the event_properties object for display — event properties are nested and vary per event type, so decide which properties are most relevant for your support use case and flatten them as columns.

1// JavaScript transformer — flatten Amplitude user events for table display
2const events = (data?.userData?.events || []);
3return events.map(event => {
4  const props = event.event_properties || {};
5  return {
6    timestamp: event.event_time
7      ? new Date(event.event_time).toLocaleString()
8      : 'N/A',
9    event_type: event.event_type || 'Unknown',
10    // Common properties — adjust to your event taxonomy
11    page: props.page || props.url || props.screen_name || 'N/A',
12    action: props.action || props.button_name || props.feature || 'N/A',
13    value: props.value || props.amount || props.duration || '',
14    device: event.device_type || 'Unknown',
15    platform: event.platform || 'Unknown',
16    country: event.country || 'Unknown',
17    session_id: event.session_id || 'N/A'
18  };
19}).sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));

Amplitude cohorts define groups of users who meet specific behavioral criteria (e.g., 'Users who completed checkout in the last 30 days'). You can export cohort membership from the Amplitude API and join it with your internal user database in Retool. First, create a query to list available cohorts: getCohorts (GET, /3/cohorts). This returns all cohorts defined in your Amplitude project with their IDs, names, and last-computed sizes. Next, create a query to export cohort members: getCohortMembers. To export a cohort, use the two-step async export process: 1. POST to /3/cohorts/request/{cohort_id} to initiate the export — Amplitude returns a request_id 2. GET /3/cohorts/request/{request_id}/file to download the cohort data once ready Since this is an async process, for smaller cohorts you can use a simpler approach: POST to /3/cohorts/request and poll for completion, or use Amplitude's synchronous export if available for your plan. Once you have the cohort member list (an array of Amplitude user IDs), create a database query that looks them up in your customers table: The combined view shows which of your customers are in the cohort, along with their account tier, revenue, and CSM ownership — giving your team actionable business context around behavioral segments.

1// SQL query — look up cohort members in your customer database
2-- amplitudeCohortIds is an array of Amplitude user IDs from the cohort export
3-- Assumes you store amplitude_user_id in your customers table
4SELECT
5  c.id,
6  c.email,
7  c.company_name,
8  c.plan_tier,
9  c.mrr,
10  c.csm_owner,
11  c.created_at,
12  c.amplitude_user_id
13FROM customers c
14WHERE c.amplitude_user_id = ANY(ARRAY[{{ getCohortMembers.data.user_ids.map(id => `'${id}'`).join(',') }}])
15ORDER BY c.mrr DESC;

Combine the event segmentation, user activity, and cohort queries into a complete analytics dashboard tailored for your product and operations teams. Top section — Event Trends Panel: A Date Range Picker component (default: last 30 days), a Dropdown for event name (options loaded from /2/taxonomy/event), and an Interval selector (Daily/Weekly/Monthly). A Chart component (bar chart) showing event counts over time from the segmentation transformer. A Stat component showing the total event count for the period. Middle section — User Activity Panel: A Text Input for Amplitude user ID or email, a Search button, and a Table showing the user's event timeline from getUserActivity. Add a JSON component showing full event properties for the selected event row. Bottom section — Cohort Analysis Panel: A Dropdown of available cohorts (from getCohorts), a 'Load Cohort' button, and a Table showing cohort members joined with your database. Add summary stats showing average MRR, most common plan tier, and cohort size. For complex analytics dashboards that connect Amplitude behavioral data with your CRM, billing, and support systems in a single Retool app, RapidDev's team can help design the multi-source data architecture. Set the event segmentation chart and stat queries to run on page load so the dashboard shows data immediately when opened.

1// JavaScript query — build event name dropdown options from Amplitude taxonomy
2const events = data?.data || [];
3const options = [
4  { label: 'All Events', value: 'any' },
5  ...events
6    .filter(e => !e.deleted)
7    .map(e => ({
8      label: e.event_type,
9      value: e.event_type
10    }))
11    .sort((a, b) => a.label.localeCompare(b.label))
12];
13return options;