Integration

Make has no clipsdk app, and it does not need one: HTTP Make a request posts the video link and a Custom webhook catches the ranked clips. A 10-minute episode costs $0.30 at $0.03 a source minute.

Make scenario for video clips: a new file in, 3 ranked clips out in under 2 minutes

You build it from two small scenarios, one that sends the file and one that catches the finished job, using only Make's own HTTP and Webhooks apps.

Get API key Pricing

Updated 7 November 2026

Or one API call

$0.03per source minute

Every clip included, up to 1080p60 and 20 Mb/s
$1 free to start, 33 minutes of video
Prepaid credit, no subscription

See pricing

HTTP Make a request settings

HTTP Make a request settings
Field	Value
Authentication type	API key, with a keychain: Key `Bearer csdk_live_...`, in the header, named `Authorization`
URL	`https://api.clipsdk.com/v1/clips?wait=0`
Method	POST
Body content type	application/JSON
Body input method	JSON string
Body content	`video_url` mapped from your trigger, `clips`, and `webhook_url` set to the Custom webhook URL
Parse response	Yes: the reply holds the job, with its `id` and `status`

Source: Make: HTTP modules, checked 7 November 2026

Build it in Make

The second scenario catches the result, so build it first: the first one needs its URL.

Create the catcher scenario
Start a new scenario with Webhooks, Custom webhook, and copy the URL Make gives you. Turn on Get request headers if you want to read Clipsdk-Signature. Make takes webhook payloads up to 5 MB on any plan (Make docs).
Store your key in a keychain
In HTTP Make a request, set Authentication type to API key and create a keychain: Key is Bearer csdk_live_..., placement is the header, parameter name is Authorization, and the allowed service origin is https://api.clipsdk.com (Make docs).
Send the video
Put Make a request (HTTP app version 4) after your trigger. The trigger has to hand over a direct https link to the video file, not a YouTube or Twitch page. URL https://api.clipsdk.com/v1/clips?wait=0, method POST, body content type application/JSON, body input method JSON string, Parse response Yes (Make docs).
Body content
```
{
  "video_url": "{{1.url}}",
  "clips": 3,
  "webhook_url": "https://hook.eu1.make.com/..."
}
```
Handle each clip
In the catcher scenario, put a filter after the webhook that only passes event equal to job.succeeded: a failed job arrives with job.error and no clips. Then add an Iterator on job.result.clips. It turns the array into one bundle per clip, so the next module (Drive, Slack, a sheet) gets each clip's video, title and post_caption on its own (Make docs).

The request the HTTP module sends

Same body as the scenario, with the episode we ran it on. The Make URL in webhook_url is where your catcher goes; our run used a test catcher. Try it opens New clips with the same video and settings.

POST/v1/clipsTry it

curl https://api.clipsdk.com/v1/clips \
  -H "Authorization: Bearer $CLIPSDK_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://api.clipsdk.com/f/lib/demo/rocket-ranch-podcast.mp4",
    "clips": 3,
    "webhook_url": "https://hook.eu1.make.com/..."
  }'

Clip 1: The Seven Minutes of Terror, 45 seconds.

Why two scenarios

A clips job takes minutes: clipsdk transcribes the episode, ranks every moment, follows the speaker and renders each clip. ?wait=0 makes clipsdk answer at once with the job id, so the HTTP module never sits on an open request. Make's own timeout tops out at 300 seconds.

When the job finishes, clipsdk POSTs the whole job to your webhook_url and the catcher scenario takes it from there. No polling loop, no Sleep module.

What the catcher receives

One POST with event set to job.succeeded or job.failed and the same job object a GET /v1/jobs/{id} returns. Every clip has a title, a score from 0 to 100, start and end in the source, a post caption, an MP4, a poster and SRT and VTT files. The links work for 7 days without a key.

Any 2xx reply counts as delivered, and Make's Custom webhook replies 200 by default. To trust a delivery without checking Clipsdk-Signature, add one more Make a request that calls GET https://api.clipsdk.com/v1/jobs/{id} with your keychain and use that answer. The webhooks docs cover the signature.

job.succeeded as our catcher got it, trimmed to one clip

{
  "event": "job.succeeded",
  "job": {
    "id": "job_o8nlghtd3oxnf09fadph",
    "status": "succeeded",
    "created_at": "2026-11-07T04:24:12.952Z",
    "finished_at": "2026-11-07T04:25:54.094Z",
    "result": {
      "clips": [
        {
          "rank": 1,
          "score": 92,
          "title": "The Seven Minutes of Terror",
          "start_s": 79.36,
          "end_s": 123.8,
          "duration_s": 44.459,
          "post_caption": "Why landing a rover on Mars is called the 'seven minutes of terror'. 🚀 #mars #nasa #space",
          "video": "https://api.clipsdk.com/f/out/job_o8nlghtd3oxnf09fadph/clip-1.mp4?s=680e3a7a..."
        }
      ]
    },
    "usage": { "source_minutes": 9.5, "clips": 3, "output_seconds": 157.2 }
  }
}

What our run returned

We sent this exact request with a 10-minute NASA podcast episode and a test catcher standing in for the Make URL. The webhook landed in under 2 minutes, on the first attempt, with 3 clips:

The Seven Minutes of Terror: score 92, 45 seconds
Searching for Biosignatures on Mars: score 85, 58 seconds
How Mars Rovers Collect Samples: score 78, 55 seconds

What it costs

clipsdk bills $0.03 per source minute, and $0.02 past 2,000 minutes a month. That episode runs just under 10 minutes, so about $0.29 at list price. Make bills its own usage on top. New accounts get $1 of free credit, enough for 33 minutes, and there is no watermark. Details on pricing.

Each account runs 3 jobs at once and 200 a day, so a scenario that fires on a big batch of files should space them out or expect a 429 with Retry-After.

Questions, answered

Is there a clipsdk app in Make?

No. The HTTP app's Make a request module sends the job and a Webhooks Custom webhook catches it. That is the whole integration: no app to install, no extra connection to approve.

Can the scenario pass a YouTube or Twitch link?

No. clipsdk needs the video file itself: a direct https link to an MP4, MOV, WebM or MKV, up to 3 hours or 5 GB. Page links are refused, so map a file link from Drive, Dropbox, S3 or your own storage.

What if the catcher scenario is off when the job finishes?

clipsdk tries 5 times: at once, then after 10 seconds, 1 minute, 5 minutes and 30 minutes. If all 5 fail, the job is still there: call `GET /v1/jobs/{id}` with the key that started it, and copy the clip files within 7 days.

Can I do it in one scenario?

Only for short videos. Use `?wait=300` and set the module's Timeout to 300 seconds, Make's maximum. The reply then holds the finished job if it ends within that: check that `job.status` is `succeeded` before you read the clips. Longer episodes come back still running, so use the webhook.

Sources

Make: HTTP modules, checked 7 November 2026
Make: API key authentication type, checked 7 November 2026
Make: Webhooks, checked 7 November 2026
Make: Iterator, checked 7 November 2026