Importly

Using Importly with Make.com

Integrate Importly's media import API into Make.com (formerly Integromat) scenarios to automate video and audio processing workflows. This comprehensive guide shows you how to build powerful automation scenarios.

What You Can Build

  • Media Automation Workflows: Process videos from multiple sources automatically
  • Content Distribution: Import once, distribute to multiple platforms
  • Archive Systems: Build automated media archiving workflows
  • Social Media Management: Download, process, and re-upload content
  • Multi-Step Processing: Combine Importly with 1,500+ apps and services

Prerequisites

  1. A Make.com account (free or paid)
  2. An Importly account with an API key
  3. Basic understanding of Make scenarios and modules

Setup Overview

Importly integrates with Make using the HTTP module for API calls and Webhooks for real-time notifications when jobs complete.

Method 1: Using Webhooks (Recommended)

This method provides real-time notifications and is the most efficient approach.

Step 1: Create a Webhook Trigger

  1. Create a new scenario in Make
  2. Add a Webhooks → Custom Webhook module as your trigger
  3. Click Create a webhook
  4. Name it: Importly Completion Hook
  5. Copy the webhook URL (you'll use this in Step 2)
  6. Click OK

Step 2: Start Media Import

  1. Add an HTTP → Make a Request module before the webhook
  2. Configure the module:

URL: https://api.importly.io/import

Method: POST

Headers:

Authorization: Bearer YOUR_IMPORTLY_API_KEY
Content-Type: application/json

Body type: Raw

Content type: JSON (application/json)

Request content:

json
1{
2  "url": "{{1.videoUrl}}",
3  "includeVideo": true,
4  "includeAudio": true,
5  "videoQuality": "1080p",
6  "audioQuality": "medium",
7  "webhookUrl": "YOUR_WEBHOOK_URL_FROM_STEP_1"
8}

Note: Replace {{1.videoUrl}} with the actual video URL from your trigger module

  1. Click OK and test the module

Step 3: Store Job ID (Optional)

After the import request:

  1. Add a Set Variable module
  2. Variable name: jobId
  3. Value: {{2.data.jobId}} (adjust number based on your module position)

This helps you track which webhook corresponds to which import.

Step 4: Process Webhook Response

The webhook module from Step 1 will receive:

json
1{
2  "type": "import.completed",
3  "data": {
4    "jobId": "abc-123",
5    "status": "completed",
6    "result": {
7      "mediaUrl": "https://storage.importly.io/...",
8      "duration": 180.5,
9      "fileSize": 25600000,
10      "creditsUsed": 25.6,
11      "format": "mp4"
12    }
13  }
14}

Step 5: Add Your Processing Logic

After the webhook, add modules to:

  • Download the media file
  • Upload to cloud storage (Google Drive, Dropbox, etc.)
  • Send notifications
  • Update databases
  • Trigger other workflows

Method 2: Polling with Delays (Alternative)

If webhooks aren't suitable for your use case, you can poll for status updates.

Step 1: Start Import

Same as Method 1, Step 2, but omit the webhookUrl field:

json
1{
2  "url": "{{1.videoUrl}}",
3  "includeVideo": true,
4  "includeAudio": true,
5  "videoQuality": "1080p",
6  "audioQuality": "medium"
7}

Step 2: Extract Job ID

  1. Add a Set Variable module
  2. Variable name: jobId
  3. Value: {{2.data.jobId}}

Step 3: Add Sleep/Delay

  1. Add a Tools → Sleep module
  2. Delay: 60-120 seconds (adjust based on typical video size)

Step 4: Check Import Status

  1. Add HTTP → Make a Request module
  2. Configure:

URL: https://api.importly.io/import/status?id={{jobId}}

Method: GET

Headers:

Authorization: Bearer YOUR_IMPORTLY_API_KEY

Step 5: Check Completion Status

  1. Add a Router module after the status check
  2. Create two routes:

Route 1: Completed

  • Filter: {{4.data.status}} = "completed"
  • Add your success actions

Route 2: Still Processing

  • Filter: {{4.data.status}} = "processing" or "queued"
  • Add another sleep and loop back (using Repeater)

Complete Example Scenarios

Example 1: YouTube to Google Drive

Automatically import videos from YouTube and save to Google Drive:

Modules:

  1. RSS → Watch RSS feed

    • Feed URL: YouTube channel RSS

  2. HTTP → Make a Request (Start Import)

    • URL: https://api.importly.io/import
    • Method: POST
    • Body: Include RSS video URL

  3. Webhooks → Custom Webhook (Catch completion)

  4. HTTP → Get a file

    • URL: {{webhook.data.result.mediaUrl}}
    • Download the media file

  5. Google Drive → Upload a File

    • File: Output from module 4
    • Folder: Your chosen folder

  6. Slack → Send Message (Optional)

    • Message: Video imported: {{webhook.data.result.mediaUrl}}

Example 2: Social Media Content Archiver

Archive content from multiple social platforms:

Modules:

  1. Watch Trigger (Multiple options):

    • Twitter mentions
    • Instagram posts
    • Facebook posts
    • Telegram messages

  2. Text Parser → Match Pattern

    • Extract URLs from post content
    • Pattern: URL regex

  3. HTTP → Make a Request (Get Metadata)

    • URL: https://api.importly.io/metadata?url={{url}}
    • Check video info before importing

  4. Filter

    • Only continue if duration < 600 seconds
    • And filesize < 500MB

  5. HTTP → Make a Request (Start Import)

  6. Webhook → Receive completion

  7. Airtable/Google Sheets → Create Record

    • Store metadata and download link

  8. AWS S3 / Dropbox → Upload

    • Permanent storage

Example 3: Automated Content Pipeline

Download, process, and redistribute content:

Modules:

  1. Google Sheets → Watch Rows

    • Monitor a sheet with URLs to process

  2. HTTP → Make a Request (Import)

    • Include webhook URL

  3. Custom Webhook → Receive completion

  4. Router (Split into multiple paths)

  5. Path 1: Cloud Storage

    • Upload to Dropbox
    • Upload to Google Drive (backup)

  6. Path 2: Notifications

    • Email notification
    • Slack message
    • Discord webhook

  7. Path 3: Database

    • Update Google Sheet with results
    • Log to Airtable

  8. Path 4: Further Processing (Optional)

    • Send to video editing API
    • Transcribe with AI service
    • Extract thumbnails

Advanced Features

Using Data Stores

Store import jobs in Make's data store for tracking:

  1. After starting import, add Data Store → Add Record

  2. Store:

    • Job ID
    • Original URL
    • Status
    • Timestamp

  3. When webhook fires, Search Record by job ID

  4. Update Record with results

Error Handling

Add error handlers to your HTTP modules:

  1. Right-click on HTTP module
  2. Select Add error handler
  3. Add Error handler route
  4. Configure what happens on error:
    • Send notification
    • Log to database
    • Retry with different parameters

Conditional Imports

Only import videos meeting certain criteria:

  1. HTTP → Make a Request (Get Metadata)
  2. Filter module with conditions:
    • Duration < 600 seconds
    • File size < 500 MB
    • Source platform = "YouTube"
  3. Only proceed to import if filter passes

Bulk Processing

Process multiple URLs:

  1. Google Sheets → Search Rows

    • Get all unprocessed URLs

  2. Iterator module

    • Iterate through each row

  3. HTTP → Make a Request (Import)

    • Process each URL

  4. Flow Control → Sleep

    • Add 1-2 second delay between requests to avoid rate limits

  5. Array Aggregator (After webhook)

    • Collect all results

  6. Google Sheets → Update Rows

    • Bulk update with results

Getting Metadata Only

To get video information without downloading:

HTTP Module Configuration:

URL: https://api.importly.io/metadata?url={{videoUrl}}

Method: GET

Headers:

Authorization: Bearer YOUR_IMPORTLY_API_KEY

Response:

json
1{
2  "success": true,
3  "data": {
4    "jobId": "meta-abc-123",
5    "status": "completed",
6    "result": {
7      "title": "Video Title",
8      "duration": 180.5,
9      "uploadDate": "2024-01-15",
10      "platform": "youtube",
11      "thumbnail": "https://...",
12      "formats": [...]
13    }
14  }
15}

Handling Different Video Qualities

Use a Router to select quality based on conditions:

  1. Add Router after metadata fetch
  2. Create routes for different qualities:

Route 1: HD (1080p)

  • Filter: File size < 100MB
  • Quality: "1080p"

Route 2: SD (720p)

  • Filter: File size > 100MB
  • Quality: "720p"

Route 3: Low (480p)

  • Fallback for large files
  • Quality: "480p"

Webhook Event Types

Handle different event types from Importly:

Import Events:

  • import.completed - Media successfully imported
  • import.failed - Import failed

Metadata Events:

  • metadata.completed - Metadata retrieved
  • metadata.failed - Metadata fetch failed

Router Configuration:

Route 1: {{webhook.type}} = "import.completed"
Route 2: {{webhook.type}} = "import.failed"
Route 3: {{webhook.type}} = "metadata.completed"

Optimization Tips

1. Reduce Operations

  • Use webhooks instead of polling
  • Batch process multiple URLs
  • Cache metadata to avoid repeated calls

2. Error Recovery

  • Add error handlers to all HTTP modules
  • Implement retry logic with delays
  • Log all errors for debugging

3. Cost Management

  • Filter before importing (use metadata first)
  • Check file sizes before download
  • Implement credit balance checks

4. Performance

  • Use parallel paths in Router for simultaneous actions
  • Implement queue systems for bulk jobs
  • Add appropriate delays to respect rate limits

Common Issues and Solutions

Issue: Webhook Not Triggering

Solutions:

  • Verify webhook URL is correct
  • Ensure scenario is activated
  • Check that webhook module is listening
  • Test webhook with Make's built-in test function

Issue: Import Takes Too Long

Solutions:

  • Large videos (>500MB) can take 5-10+ minutes
  • Increase sleep duration in polling method
  • Use webhooks for better reliability
  • Check job status manually if needed

Issue: Rate Limit Errors (429)

Solutions:

  • Add delays between requests (1-2 seconds)
  • Use Flow Control → Sleep modules
  • Reduce concurrent operations
  • Check your Make plan's operation limits

Issue: Invalid API Key (401)

Solutions:

  • Verify API key from dashboard
  • Ensure format is: Bearer YOUR_API_KEY (with space)
  • Check for extra spaces or line breaks
  • Re-copy API key to ensure accuracy

Monitoring and Debugging

Add Logging

  1. After each HTTP call, add Tools → Set Variable
  2. Log response data for debugging
  3. View in scenario execution history

Email Notifications

Add Email module after critical steps:

  • When import succeeds
  • When errors occur
  • Daily summary of imports

Execution History

  • View complete execution history in Make
  • Filter by success/error
  • Analyze bottlenecks
  • Track operation usage

Pricing Considerations

Make.com:

  • Each module execution counts as an operation
  • Webhooks are efficient (1 operation per trigger)
  • Polling uses operations for each check
  • Consider plan limits when designing scenarios

Importly:

  • Charged per MB downloaded
  • Metadata requests are free
  • Credits deducted only for completed imports

Optimization Strategy:

  1. Get metadata first (free)
  2. Check file size
  3. Filter based on size/duration
  4. Import only what you need

Best Practices

  1. Always Use Error Handlers: Catch and handle errors gracefully
  2. Implement Logging: Track all imports and failures
  3. Use Webhooks: More reliable than polling
  4. Add Delays: Respect rate limits with sleep modules
  5. Test Incrementally: Build and test module by module
  6. Monitor Credits: Track Importly credit usage
  7. Document Scenarios: Add notes to complex scenarios
  8. Version Control: Clone scenarios before major changes

Security Best Practices

  1. API Key Storage: Use Make's secure connection storage
  2. Webhook Security: Validate webhook sources (advanced)
  3. Data Privacy: Handle media URLs securely
  4. Access Control: Limit scenario access to necessary team members

Resources

Example Scenario Templates

Download ready-to-use scenario templates:

  1. YouTube to Cloud Storage - Monitor and archive channel content
  2. Social Media Archiver - Multi-platform content backup
  3. Content Distributor - Download once, upload to multiple destinations
  4. Bulk URL Processor - Process spreadsheet of video URLs
  5. Smart Importer - Quality selection based on file size

Contact [email protected] for scenario blueprints

Need Help?

Next Steps

  1. Create your first scenario with a simple import
  2. Test with a short video
  3. Add webhook handling
  4. Implement error handling
  5. Build complex multi-step workflows
  6. Monitor and optimize operation usage
Bubble.ioAuthentication & Security