Make

Social Fetch has an app for Make. Add one of its modules to a scenario, pick a platform and fill in a handle, URL or search, and it returns live public data (profiles, posts, comments, transcripts, ads, web pages) that you can send on to Google Sheets, Airtable, Slack, an AI step or anything else in Make. You don't need to set up HTTP requests.

The app isn't in Make's public app list yet. You install it from an invite link, once per Make organization.

What you'll need

• A Make account, with permission to install apps in your organization.
• A Social Fetch API key. It starts with sfk_. Step 1 shows how to make one.
• Credits on your Social Fetch account. Every module run that fetches data uses credits, including the runs you do while testing. See Credits and billing.

Step 1: Create an API key

Give Make its own key, so you can tell its calls apart and revoke it without breaking anything else.

1. Open API Keys in the Social Fetch app.
2. Under New API key, type a name such as Make, then click Create key.

3. Copy the key from the Save your API key window. It's only shown once; if you lose it, create another.

Step 2: Install the app in Make

1. Open the invite link and sign in to Make.
2. Install Social Fetch in the organization where you build scenarios.

Screenshot placeholderTo capture: the Make app invitation page for Social Fetch, opened from the invite link while signed in to Make, showing the Social Fetch app name and logo and the button that installs it. Box the install button with the label 'Install it in your organization'. Cover the Make account email and organization name if they show.

Everyone in that organization can then use it in their scenarios.

Step 3: Add a module and connect your key

1. Open a scenario in Make and click the + to add a module.
2. Search for Social Fetch and pick a module, for example Get a profile. The module catalog lists them all.

Screenshot placeholderTo capture: the Make scenario editor with the add-module search open, Social Fetch typed in the search box, and the Social Fetch app's list of modules showing (Get a profile, Get a post, List posts and so on). Box Get a profile with the label 'Pick a module'.

3. In the module, click Create a connection next to Connection.
4. Paste your sfk_ key into API key and save.

Screenshot placeholderTo capture: the Make connection window for Social Fetch, opened from Create a connection inside a Social Fetch module, with the Connection name field and the API key field. Cover the pasted key, box the API key field with the label 'Paste your sfk_ key', and point at the save button.

Make checks the key with Social Fetch when you save, and the check is free. If the key is wrong, Make shows Invalid API key and doesn't save the connection. You only do this once: every Social Fetch module in your organization can use the same connection.

Step 4: Run a module

Most modules start with Platform. Pick it first, and the fields below it change to match.

1. In Get a profile, set Platform to TikTok and Handle to nasa.
2. Click OK, then Run once at the bottom of the scenario editor.
3. Click the bubble above the module to see what came back.

Screenshot placeholderTo capture: the Make scenario editor after Run once on a Social Fetch Get a profile module set to TikTok and the handle nasa. The output bubble above the module is open, showing Bundle 1 with the profile fields (handle, nickname, follower count and so on). Box the output panel with the label 'The profile, ready for the next module'.

What a module returns depends on its type:

• Actions, such as Get a profile or Get a post, return one bundle: the data part of the API response.
• Searches, such as List posts or Search content, return one bundle per result, so the next module runs once for each post or comment. They keep fetching pages until they reach Limit, which is 10 unless you change it. Each page is a separate call that costs credits, so raise Limit only as far as you need.
• Make an API call sends a request to any Social Fetch API path, such as /v1/tiktok/profiles/nasa, with your connection's key. It returns the whole response: body, headers and statusCode.

Every module calls an endpoint from the API reference. That endpoint's page lists every field the output can have and what a call costs.

See each run in Social Fetch

Modules return the data without the response's meta, so Make doesn't show what a run cost. Social Fetch does. Open Request history and type part of the path, such as /tiktok/profiles/nasa, into Path contains. Each call is listed with its status and what it cost, newest first, and failed calls are there too; a search that fetched three pages shows three rows. The free connection check isn't listed.

Click a row to see the details: the endpoint, the credits it cost, the parameters Make sent and the response. The Request ID is the one Make shows in its error messages, so it's the thing to send to support if a run goes wrong.

To read your balance inside a scenario, use the Get a credit balance module.

Watch for new posts

The Watch new items module starts a scenario when an account, search, hashtag or subreddit has something new. Make doesn't do the checking: when you save the trigger's webhook, Social Fetch creates a monitor that checks the source on a schedule and sends what's new to Make.

1. Add Social Fetch > Watch new items as the first module of a scenario.
2. Click Create a webhook, pick a Source (for example New videos from a profile), fill in the handle or query, and set Check interval (minutes).
3. Save the webhook. The monitor appears under Monitors in the Social Fetch app, named after what it watches, such as Profile videos · @nasa.
4. Turn the scenario on.

Screenshot placeholderTo capture: the Make webhook window for Social Fetch Watch new items, opened from Create a webhook, with Source set to New videos from a profile, a Handle filled in and Check interval (minutes) set to 60. Box the Source field with the label 'Pick what to watch', and point at Check interval with 'Each check costs credits'.

Things to know before you rely on it:

• Each check costs credits, at the price of the endpoint it watches, whether or not it finds anything. The first check runs as soon as the monitor is created and records what's already there, so older posts don't start the scenario. Billing for monitors shows how to work out the cost of an interval.
• New posts arrive together. Each delivery is one bundle, with the new posts in data.items. Add an Iterator on data.items to handle them one at a time. The other fields follow the monitor event format.
• Delete the webhook to stop the checks. Deleting the webhook in Make deletes the monitor. Turning the scenario off doesn't, so the monitor keeps checking and spending credits. You can also pause or delete the monitor in the Social Fetch app.
• Monitors need a purchase on record. An account that has only ever used free sign-up credits gets "Monitors requires at least one credit pack purchase or subscription" when it saves the webhook.

Troubleshooting

Make shows the message from Social Fetch, followed by the request ID, such as (requestId=req_…). Find that ID in Request history to see the whole call.

Invalid API key. The key in the connection is wrong, revoked or expired. Create a new key, then edit the connection in Make (or create a new one) and paste it in.

Not enough credits (HTTP 402). Your Social Fetch balance can't cover the call, or the key has a monthly spend limit and has reached it. Make treats this as a configuration error and may turn the scenario off. Add credits under Billing or raise the key's limit, then turn the scenario back on.

Rate limited (HTTP 429). Too many calls at once. Space the runs out, or lower Limit on searches.

The run is green but returned nothing. The profile or post may be private, deleted or misspelled, or a search found no matches. Check the row in Request history: the response shows what Social Fetch found.

Watch new items didn't start the scenario. Check that the scenario is on, then open the monitor in Monitors: its page shows the last check and any new items it found. The first check only records what's already there, so the scenario runs only when a later check finds something new. If the monitor found something, open Monitors > Webhooks and the endpoint with Make's webhook address: its delivery log shows whether Make accepted each event.

Still stuck? Contact support with the request ID.

Next steps