Getty Images API

Open developers.gettyimages.com in your browser and sign in or create a free account. Navigate to My Account → Applications and click Create Application. Enter your app name, description, and intended use (select Developer / Non-commercial for the free tier). After submission, Getty will display your API Key and API Secret — copy both immediately and store them in a secure location such as a password manager or your Firebase/Supabase secrets panel. These two values are what your backend proxy will use to obtain Bearer tokens. Getty also provides a sandbox environment for testing at https://api.gettyimages.com/v3 — the same URL is used for both sandbox and production on the developer tier, but responses include watermarked images. If you eventually move to a Partner agreement, Getty provides separate Partner credentials with different rate limits and access to clean, licensed image downloads. For now, keep your API Key visible in the developer console; you will reference it when setting up both the proxy function and the FlutterFlow API Call headers.

Getty's token exchange endpoint (https://authentication.gettyimages.com/oauth2/token) accepts your client_id (API Key), client_secret, and grant_type=client_credentials and returns an access_token valid for a limited window. This exchange must happen server-side because the client_secret cannot be embedded in your Flutter app. In your Firebase console open Functions or in Supabase open Edge Functions. Create a new function named gettyToken. Set environment variables GETTY_API_KEY and GETTY_API_SECRET to your credentials using Firebase Functions Secrets or Supabase's secrets panel — never hardcode them in the function source code. The function sends a POST request to Getty's token URL with the credentials, then returns just the access_token and its expiry to FlutterFlow. Deploy the function and note its HTTPS URL. Test the proxy by calling its URL in a browser or in Postman before wiring it to FlutterFlow. A successful response looks like: {"access_token": "ey...", "expires_in": 1800}. If the proxy returns an error, check that the environment variables are spelled correctly (GETTY_API_KEY, not GETTY_CLIENT_ID, for example — match exactly what your function code reads).

1// Firebase Cloud Function — Getty token proxy (Node.js)
2const functions = require('firebase-functions');
3const axios = require('axios');
4
5exports.gettyToken = functions.https.onRequest(async (req, res) => {
6  res.set('Access-Control-Allow-Origin', '*');
7  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
8
9  const apiKey = process.env.GETTY_API_KEY;
10  const apiSecret = process.env.GETTY_API_SECRET;
11
12  try {
13    const params = new URLSearchParams({
14      grant_type: 'client_credentials',
15      client_id: apiKey,
16      client_secret: apiSecret,
17    });
18    const resp = await axios.post(
19      'https://authentication.gettyimages.com/oauth2/token',
20      params.toString(),
21      { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
22    );
23    res.json({
24      access_token: resp.data.access_token,
25      expires_in: resp.data.expires_in,
26    });
27  } catch (err) {
28    res.status(500).json({ error: 'token_error', detail: err.message });
29  }
30});

In FlutterFlow, open API Calls in the left navigation bar. Click + Add → Create API Group and name it Getty Token Proxy. Set its Base URL to your deployed Cloud Function URL (e.g. https://us-central1-your-project.cloudfunctions.net). Add one API Call inside this group named getToken, method GET, no additional headers. This call returns the access_token you will cache in App State. Create a second API Group named Getty Images API with Base URL https://api.gettyimages.com/v3. In the Headers section add two headers: Authorization with value Bearer {{token}} and Api-Key with value {{apiKey}}. Add two group-level variables: token (String) and apiKey (String). The apiKey value is your Getty API Key — this is a public identifier and is acceptable in an API Call header (unlike the secret, which stays server-side). Inside the Getty Images API group, add an API Call named searchImages, method GET, endpoint /search/images. Add variables: phrase (String, required), image_type (String, default to 'photography'), and sort_order (String, default to 'best_match'). Add a query parameter fields with value display_set,title,id to request only the fields you need — this reduces response size and speeds up parsing. In the Response & Test tab, paste a sample Getty search response and click Generate JSON Paths. Key paths to note: $.images[0].display_sizes[0].uri (the watermarked preview URL), $.images[0].title, $.images[0].id, and $.images[0].referral_destinations[0].uri (the link to the full Getty page).

1// API Call config reference for Getty image search
2{
3  "method": "GET",
4  "endpoint": "/search/images",
5  "headers": {
6    "Authorization": "Bearer {{token}}",
7    "Api-Key": "{{apiKey}}"
8  },
9  "query_params": {
10    "phrase": "{{phrase}}",
11    "image_type": "{{image_type}}",
12    "sort_order": "{{sort_order}}",
13    "fields": "display_set,title,id"
14  }
15}
16// Key JSON paths:
17// $.images[0].display_sizes[0].uri  → watermarked preview URL
18// $.images[0].title
19// $.images[0].id
20// $.images[0].referral_destinations[0].uri

Create a search screen in FlutterFlow with a TextField widget for the search query. Also add a GridView widget that will display search results, and a CircularProgressIndicator that shows while results are loading. In App State, create three variables: gettyToken (String), gettyTokenExpiry (DateTime), and gettyApiKey (String — set this to your API Key as a constant, since it is a public identifier). On screen load (OnPageLoad Action Flow): check if gettyToken is empty or if the current time is past gettyTokenExpiry. If so, call the Getty Token Proxy getToken API Call, store the returned access_token in gettyToken, and set gettyTokenExpiry to now plus expires_in seconds. This caches the token for its valid lifetime. For the search TextField, you want debounce: instead of calling the API on every keystroke, add a Timer widget set to fire 600ms after the last key press. There are two ways to do this in FlutterFlow: use the TextField's onChange action with a delay parameter in a Wait action, or use a page-level timer variable that resets on each keystroke. When the timer fires, check if the text field has at least 2 characters, then call searchImages with the current text as phrase, passing gettyToken and gettyApiKey from App State. Map the returned images array to a page variable named searchResults. Inside the GridView, bind each item's display_sizes[0].uri to an Image widget's network URL. Add an overlay Text widget showing the image title. Add a tap action that opens the referral_destinations[0].uri in a WebView or launches it in the device's external browser.

Getty's free Developer tier enforces strict request rate limits. In the Action Flow Editor for the searchImages API Call, add an error branch: when the response status code is 429, show a SnackBar message saying 'Too many searches — please wait a moment and try again' and disable the search field for 5 seconds before re-enabling it. This prevents users from hammering the retry button. You can implement the 5-second cooldown with a Timer action that sets a Boolean App State variable isSearchDisabled to true, waits 5 seconds, then sets it back to false. Bind the TextField's enabled state to that Boolean. For the licensing disclaimer, add a Text widget below the GridView with wording such as: 'Images shown are watermarked previews. Licensing for commercial use requires a Getty Images Partner agreement. Tap any image to view licensing options on Getty.com.' Do not imply that users can freely download or use these images commercially — Getty enforces its licensing terms strictly and this could create legal exposure for your app. Also handle 401 errors: add an error branch that clears gettyToken in App State and re-fetches the token from the proxy before retrying the search. This handles the case where the token expires mid-session (Getty tokens are typically valid for 30 minutes on the free tier — check the current expires_in value from the token response for the actual window).

If your app includes a download or save button on search results, gate it behind a clear licensing flow. For the free Developer tier, the recommended pattern is to open Getty's referral URL in an external browser where users can license images directly on Getty's website. Do not attempt to download or cache the watermarked preview URIs as permanent assets — Getty's terms of service restrict this use. For the web build of your FlutterFlow app, test the Getty API Calls in Chrome DevTools Network tab to confirm no CORS errors appear. Since your FlutterFlow app calls Getty's API directly with a Bearer token (not through a proxy), some browser environments may flag CORS if Getty does not include a permissive Access-Control-Allow-Origin header for your domain. If you see XMLHttpRequest errors in the web preview, route the search calls through your Cloud Function proxy as well (not just the token exchange) to avoid CORS issues. For native iOS and Android builds, CORS is not enforced, so direct Getty API Calls work fine. Test on a physical device to verify image loading performance — Getty preview images can be large, and you may want to add the display_size=thumb query parameter to request smaller thumbnails in the grid view. If you'd rather skip the custom token-proxy setup entirely, RapidDev's team builds FlutterFlow integrations like this one every week — book a free scoping call at rapidevelopers.com/contact.