SOKE
Integrations

Make (Integromat)

Build no-code content optimization scenarios with Soke and Make — includes downloadable blueprint templates.

Make Integration

Use Soke with Make (formerly Integromat) to build visual, no-code content optimization scenarios. This guide covers connection setup, working with Soke's API responses, and includes downloadable scenario blueprints.

What you can build

  • Automated keyword research — schedule keyword research and push results to Google Sheets, Airtable, or your CMS
  • Content optimization pipelines — chain keyword research → title optimization → description generation into a single scenario
  • Thumbnail generation with polling — start async thumbnail generation and automatically poll until the image is ready
  • Chat-powered workflows — use Soke's OpenAI-compatible endpoint for complex, multi-service requests

Prerequisites


Connection Setup

Add an HTTP module

In your scenario, click the + button and search for HTTP. Select HTTP → Make a request.

Configure the request

Fill in the following fields:

FieldValue
URLhttps://api.usesoke.ai/api/v1/research/keywords
MethodPOST
HeadersAdd two headers (see below)
Body typeRaw
Content typeJSON (application/json)
Request contentYour JSON payload

Headers to add:

Header NameHeader Value
Content-Typeapplication/json
X-Soke-Keysk_live_your_api_key

You'll reuse the same two headers across every Soke HTTP module. Consider creating a Make connection (custom HTTP connection) to avoid repeating them — go to Connections → Create a connection → HTTP and pre-fill the headers.

Enable response parsing

Check the Parse response checkbox. This lets you access response fields directly in subsequent modules without needing a separate JSON parse step.

Test the module

Click Run this module only. You should see a response with data.success: true and your keyword results under data.data.keywords.


Understanding Soke Responses in Make

Every Soke response follows a standard envelope:

{
  "success": true,
  "data": { /* results */ },
  "meta": { "platform": "youtube", "request_id": "uuid", "processing_time_ms": 142 }
}

With Parse response enabled, Make maps the response to a nested structure. Access fields in subsequent modules using this mapping:

What you needMake reference
Success flagdata.success
Keywords arraydata.data.keywords
First keyworddata.data.keywords[1].keyword
Long-tail phrasesdata.data.longTailPhrases
Processing timedata.meta.processing_time_ms

Make uses 1-based indexing for arrays. The first keyword is data.data.keywords[1], not data.data.keywords[0].


Scenario: Keyword Research

A simple scenario to research keywords and output structured results.

Module 1: HTTP → Make a request

  • URL: https://api.usesoke.ai/api/v1/research/keywords
  • Method: POST
  • Headers: Content-Type: application/json, X-Soke-Key: sk_live_...
  • Body type: Raw
  • Content type: JSON
  • Request content:
{
  "topic": "productivity tips for developers",
  "platform": "youtube",
  "maxResults": 20
}
  • Parse response: ✅ Checked

Module 2: Iterator (optional)

If you want to process each keyword individually, add an Iterator module:

  • Array: data.data.keywords

This creates one bundle per keyword, letting you map individual fields like keyword, competitionScore, trendDirection in downstream modules.

Module 3: Output

Connect to your destination:

  • Google Sheets: Map keyword, competitionScore, trendDirection, searchVolume to columns
  • Airtable: Create records with keyword data
  • Slack: Send a formatted summary of top keywords

Scenario: Content Optimization Pipeline

Chain three Soke endpoints to go from topic to fully optimized content.

Pipeline: Keywords (2 credits) → Title (3 credits) → Description (3 credits) = 8 credits total

Module 1: Research Keywords

HTTP module configured as above with your topic.

Module 2: Optimize Title

Add a second HTTP module:

  • URL: https://api.usesoke.ai/api/v1/content/optimize-title
  • Method: POST
  • Request content:
{
  "draftTitle": "How to boost your productivity as a developer",
  "platform": "youtube",
  "keywords": {{toJSON(map(slice(1.data.data.keywords; 0; 5); "keyword"))}}
}

This extracts the top 5 keyword names from Module 1's response and passes them to the title optimizer.

Module 3: Generate Description

Add a third HTTP module:

  • URL: https://api.usesoke.ai/api/v1/content/generate-description
  • Method: POST
  • Request content:
{
  "title": "{{2.data.data.alternatives[1].title}}",
  "platform": "youtube",
  "keywords": {{toJSON(map(slice(1.data.data.keywords; 0; 5); "keyword"))}},
  "niche": "tech",
  "tone": "casual"
}

This uses the best optimized title from Module 2 and the keywords from Module 1.

Module 4: Output

Add a Set variable or connect directly to Google Sheets/Notion:

  • Optimized title: {{2.data.data.alternatives[1].title}}
  • Title score: {{2.data.data.alternatives[1].overallScore}}
  • Description: {{3.data.data.description}}

Scenario: Async Job Handling (Thumbnails & Transcription)

Thumbnail generation and transcription are async — they return a job ID, and you poll for results.

The polling pattern in Make

Start Job → Repeater (max 10) → Sleep (5s) → Poll Status → Router
                                                             ├─ Completed → Output
                                                             └─ Processing → (continue loop)

Module 1: Start the job

Thumbnail generation:

  • URL: https://api.usesoke.ai/api/v1/thumbnail/generate
  • Method: POST
  • Request content:

Using a template (recommended — create one in the Soke dashboard for consistent styling):

{
  "manualTitle": "10 Developer Productivity Hacks",
  "manualPrompt": "A developer at a clean desk with multiple monitors",
  "templateId": "your-template-id",
  "platform": "youtube"
}

Or without a template (all parameters required). Supported resolutions: 1280x720 (landscape) or 1080x1920 (portrait/shorts):

{
  "manualTitle": "10 Developer Productivity Hacks",
  "manualPrompt": "A developer at a clean desk with multiple monitors",
  "colorGrading": "Cinematic",
  "layoutType": "TextCenter",
  "resolution": "1280x720",
  "platform": "youtube"
}

Transcription:

  • URL: https://api.usesoke.ai/api/v1/transcription
  • Method: POST
  • Body type: Multipart/form-data
  • Fields: url = https://youtube.com/watch?v=VIDEO_ID

Module 2: Repeater

Add a Flow Control → Repeater module:

  • Initial value: 1
  • Repeats: 10 (maximum polling attempts)

This creates a loop that runs up to 10 times.

Module 3: Sleep

Add a Tools → Sleep module:

  • Delay: 5 (seconds for thumbnails) or 10 (seconds for transcription)

Module 4: Poll status

Add an HTTP module:

Thumbnail:

  • URL: https://api.usesoke.ai/api/v1/thumbnail/{{1.data.data.id}}
  • Method: GET

Transcription:

  • URL: https://api.usesoke.ai/api/v1/transcription/{{1.data.data.id}}
  • Method: GET

Module 5: Router

Add a Flow Control → Router module with two routes:

Route 1 — Completed:

  • Filter: data.data.status equals Completed (thumbnail) or completed (transcription)
  • Action: Set variable or send to output

Route 2 — Still processing:

  • Filter: data.data.status does not equal Completed/completed
  • Action: Continue (the repeater loop handles retries automatically)

If the job isn't completed after all repeater iterations, the scenario ends without a result. For production use, add an error notification route that triggers after the final iteration.


Scenario: Chat Completions

Use Soke's chat endpoint for natural language content tasks:

  • URL: https://api.usesoke.ai/api/v1/chat/completions
  • Method: POST
  • Request content:
{
  "messages": [
    {
      "role": "user",
      "content": "Research keywords for cooking tutorials and suggest 3 optimized titles"
    }
  ],
  "platform": "youtube",
  "model": "soke-v1",
  "stream": false
}

Access results:

FieldMake reference
AI responsedata.choices[1].message.content
Services useddata.choices[1].message.data.services_used
Raw resultsdata.choices[1].message.data.results

Downloadable Blueprints

Import these into Make via Scenarios → Create a new scenario → Import Blueprint (paste the JSON content).

After importing, update the X-Soke-Key header value in each HTTP module with your actual API key.

ScenarioDescriptionCreditsDownload
Keyword ResearchResearch keywords for a topic2keyword-research.json
Content PipelineKeywords → Title → Description8content-pipeline.json
Thumbnail GenerationGenerate thumbnails with polling4thumbnail-generation.json
TranscriptionTranscribe video with polling1transcription.json

Error Handling

Setting up error handlers

Wrap each HTTP module in an Error Handler to catch API errors gracefully:

  1. Right-click the HTTP module → Add error handler
  2. In the error handler route, add a Router with conditions:
Error CodeStatusAction
RATE_LIMIT_EXCEEDED429Add a Sleep module (use Retry-After value), then retry
INSUFFICIENT_CREDITS402Send a notification (Slack, email) to top up credits
SUBSCRIPTION_REQUIRED403Alert that subscription is inactive
PLATFORM_NOT_IMPLEMENTED501Log and skip — platform not yet supported
Server errors5xxCredits are auto-refunded; retry after a short delay

Retry pattern for rate limits

  1. Error Handler catches the 429 response
  2. Sleep module waits for the Retry-After duration (typically 30–60 seconds)
  3. HTTP module retries the same request
  4. Break directive stops retrying after 3 attempts

Credit monitoring

Add a scheduled scenario that runs daily to check your credit balance:

  • URL: https://api.usesoke.ai/api/v1/credits/balance
  • Method: GET
  • Check data.data.currentBalance — if below a threshold, send a Slack/email alert

Monitor your credit usage when running automated scenarios. A content pipeline running daily uses 8 credits/day ≈ 240 credits/month. Check plan limits on the Rate Limiting & Credits page.

On this page