How to Integrate Retool with Postman

Before sending any requests in Postman, create an Environment to store your API credentials. In Postman, click the 'Environments' section in the left sidebar and click the '+' button to create a new environment. Name it after the API you are testing (e.g., 'Stripe Production' or 'Salesforce Dev'). Add variables for the base URL and authentication credentials. For example, if connecting to a REST API with an API key, add variables: BASE_URL with the API's base URL, and API_KEY with your actual key. Mark sensitive values like API keys as 'secret' type in Postman, which masks the value in the UI and prevents accidental exposure. With the environment configured, you can reference variables in requests using {{VARIABLE_NAME}} syntax — the same double-curly syntax Retool uses. This makes it easy to map Postman environments to Retool configuration variables later.

1// Postman environment variables (maps to Retool config vars)
2// BASE_URL = https://api.example.com
3// API_KEY = your-api-key-here
4// TOKEN = (populated by pre-request script if using OAuth)
5
6// Example Postman request using environment variables:
7// GET {{BASE_URL}}/v1/customers
8// Headers:
9//   Authorization: Bearer {{API_KEY}}
10//   Content-Type: application/json

With your environment configured, create a new request in Postman. Click 'New' → 'HTTP Request'. Set the method (GET, POST, PUT, DELETE) and enter the endpoint URL using environment variables: {{BASE_URL}}/v1/endpoint-path. In the Headers tab, add the required authentication header — typically 'Authorization: Bearer {{API_KEY}}' for token auth, or use the Authorization tab's built-in options for Basic Auth, OAuth 2.0, or API Key. In the Params tab, add any required query parameters. Click 'Send'. Examine the response in the response panel. Pay attention to the HTTP status code, the response body structure, and any important headers (like X-RateLimit-Remaining or pagination headers). If you get a 401 or 403, double-check that the environment is selected and variables are populated. If you get unexpected data, try a simpler endpoint first (like a 'ping' or 'me' endpoint) to confirm authentication works before testing complex endpoints.

Once Postman confirms your request works, translate the configuration to Retool. In Retool, go to Resources → Create New → REST API. The mapping from Postman to Retool is direct: Postman's BASE_URL environment variable becomes Retool's Base URL field. Postman's global headers (set in the Collection's Headers tab) become Retool Resource-level default headers. Postman's Authorization configuration maps to Retool's authentication section — choose the same auth type (Basic, Bearer, API Key, OAuth 2.0) and enter the same credentials. Store credentials in Retool configuration variables (Settings → Configuration Variables) and reference them as {{ retoolContext.configVars.VARIABLE_NAME }} in the Resource headers, just as you used {{VARIABLE_NAME}} in Postman. The Resource-level configuration in Retool is equivalent to Postman's Collection-level settings — it applies to all queries that use this Resource.

1// Mapping: Postman → Retool
2// Postman Collection Base URL → Retool Resource Base URL
3// Postman Collection Headers → Retool Resource Default Headers
4// Postman Environment {{API_KEY}} → Retool {{ retoolContext.configVars.API_KEY }}
5// Postman Request Method → Retool Query Method dropdown
6// Postman Request Path → Retool Query Path field
7// Postman Request Params → Retool Query Parameters section
8// Postman Request Body → Retool Query Body section
9// Postman Tests assertions → Retool Query transformer validation

For each Postman request you want to replicate in Retool, create a new query using the Resource you just created. The path field in Retool's query editor corresponds to the path portion of Postman's request URL (everything after the base URL). Query parameters in Postman's Params tab become query parameters in Retool's query editor. Request headers specific to the request (not the collection) become per-query headers in Retool. The request body in Postman becomes Retool's Body section — select the same body type (JSON, form data, raw) and paste the same structure. Replace any hard-coded values in Postman with Retool's dynamic {{ component.value }} syntax. For example, if Postman has 'customer_id': '123' in the body, Retool's version becomes 'customer_id': '{{ customerId.value }}' where customerId is a TextInput component in your app.

1// Postman request (hard-coded values):
2// POST https://api.example.com/v1/customers
3// Body: { "email": "test@example.com", "name": "Test User" }
4
5// Retool equivalent (dynamic values from components):
6// POST /v1/customers (path field, Base URL already set in Resource)
7// Body:
8{
9  "email": "{{ emailInput.value }}",
10  "name": "{{ nameInput.value }}"
11}

After verifying queries work in Retool, use Postman's saved response examples to design and test your transformer logic offline before applying it in Retool. In Postman, save a response by clicking 'Save as Example' on any response. This saves the actual JSON structure as a reference. Open Postman's console or use a JavaScript runner like Node.js REPL to prototype your transformer function against the saved example data. Write the same transformation logic you would use in a Retool transformer — map, filter, reduce operations that flatten nested objects into table-ready rows. Once the transformer logic works against your Postman example data, paste the function body into Retool's transformer editor. This approach is particularly valuable for complex APIs with deeply nested responses where debugging inside Retool can be slow.

1// Prototype this transformer logic using Postman response example as input:
2// (Then paste into Retool's transformer editor)
3
4const rawData = data; // In Retool, 'data' = the query response
5
6// Example: flatten a paginated API response
7const results = rawData.data || rawData.results || rawData.items || [];
8
9return results.map(item => ({
10  id: item.id,
11  name: item.name || item.title || 'Unnamed',
12  status: item.status || 'unknown',
13  created: item.created_at
14    ? new Date(item.created_at).toLocaleDateString()
15    : 'N/A',
16  email: item.email || item.customer?.email || '',
17  amount: item.amount !== undefined
18    ? `$${(item.amount / 100).toFixed(2)}`
19    : ''
20}));