Make (Integromat) Integration

Connect OilPriceAPI with Make (formerly Integromat) to build sophisticated visual automation scenarios. Track oil prices, create complex multi-step workflows, and integrate commodity data with your business applications. Ideal for logistics automation, fleet management workflows, and commodities trading alerts.

Overview

Make offers a visual, drag-and-drop interface for building automation workflows called "scenarios." Its powerful data transformation capabilities make it ideal for processing and routing oil price data to multiple destinations.

Why Use Make for Oil Price Automation:

  • Visual workflow builder with real-time execution preview
  • Advanced data transformation and filtering
  • Support for complex branching and conditional logic
  • Detailed execution history and error handling
  • Connect to 1,500+ applications

Prerequisites

Before you begin:

  1. An active OilPriceAPI account with API key (Sign up)
  2. A Make account (Create free account)
  3. Access to destination apps (Google Sheets, Slack, databases, etc.)

Step-by-Step Setup

Step 1: Create a New Scenario

  1. Log in to your Make dashboard
  2. Click Create a new scenario
  3. You'll see a blank canvas with a large + icon

Step 2: Add an HTTP Module for OilPriceAPI

  1. Click the + icon to add your first module
  2. Search for HTTP
  3. Select Make a request
  4. Configure the request:

URL:

https://api.oilpriceapi.com/v1/prices/latest

Method: GET

Headers:

NameValue
AuthorizationToken YOUR_API_KEY
Content-Typeapplication/json

Query String (optional):

NameValue
by_codeBRENT_CRUDE_USD,WTI_USD
  1. Click OK to save the module

Step 3: Add a Scheduler Trigger

  1. Click the clock icon on the left side of the HTTP module
  2. Choose your schedule frequency:
    • At regular intervals: Every 15 minutes, hourly, etc.
    • Every day: At a specific time
    • Days of the week: Business days only

Step 4: Parse the JSON Response

  1. Click the + after your HTTP module
  2. Search for JSON
  3. Select Parse JSON
  4. Map the Body from your HTTP module to the JSON module
  5. Click Run once to generate the data structure

Step 5: Connect to Your Destination

Add modules to send your oil price data where you need it.

Example: Send to Slack

  1. Click + after the JSON module
  2. Search for Slack
  3. Select Create a Message
  4. Connect your Slack account
  5. Configure:
    • Channel: Select your target channel
    • Text:
    Oil Price Update
Brent Crude: ${{1.data.items[1].price}}
WTI: ${{1.data.items[2].price}}
Updated: {{formatDate(now; "MMMM DD, YYYY HH:mm")}}

Step 6: Test and Activate

  1. Click Run once to test the entire scenario
  2. Review execution results in the bottom panel
  3. Click the Scheduling toggle to activate your scenario

Visual Workflow Patterns

Pattern 1: Multi-Destination Price Distribution

Send oil prices to multiple destinations simultaneously using Make's router.

[Scheduler] → [HTTP: Get Prices] → [JSON Parse] → [Router]
                                                     ├→ [Slack: Team Channel]
                                                     ├→ [Google Sheets: Log Row]
                                                     └→ [Email: Daily Summary]

Setup:

  1. After JSON Parse, add a Router module
  2. Create separate branches for each destination
  3. Each branch processes independently

Pattern 2: Conditional Price Alerts

Only send alerts when prices meet specific criteria.

[Scheduler] → [HTTP: Get Prices] → [JSON Parse] → [Filter] → [Email Alert]

Filter Configuration:

  1. Add a Filter between JSON Parse and your alert module
  2. Set condition: {{1.data.items[1].price}} greater than 85
  3. Add label: "Price Above $85"

Pattern 3: Historical Data Aggregation

Collect and aggregate price data over time.

[Scheduler: Every Hour] → [HTTP: Get Prices] → [JSON Parse] → [Data Store: Add Record]
                                                                        ↓
[Scheduler: Daily] → [Data Store: Search Records] → [Iterator] → [Aggregator] → [Google Sheets]

Pattern 4: Price Change Calculator

Calculate and report price changes.

[Scheduler] → [HTTP: Get Prices] → [JSON Parse] → [Data Store: Get Yesterday] → [Math: Calculate Change] → [Slack]

Advanced Techniques

Using Variables for Dynamic Requests

Store your API key as a variable for easy management:

  1. Go to Scenarios > Variables
  2. Create variable: oilpriceapi_key
  3. In HTTP module, use: Token {{variables.oilpriceapi_key}}

Iterating Through Multiple Commodities

Process each commodity separately:

  1. After JSON Parse, add an Iterator module
  2. Map: {{1.data.items}}
  3. Each subsequent module receives one commodity at a time

Error Handling

Add error handling routes:

  1. Right-click your HTTP module
  2. Select Add error handler
  3. Choose Resume with notification or Rollback
  4. Add email notification for failures

Data Transformation Functions

Make provides powerful functions for data manipulation:

FunctionExampleResult
formatNumber{{formatNumber(85.42; 2; ","; ".")}}85,42
round{{round(85.427; 2)}}85.43
parseDate{{parseDate(1.updated_at; "YYYY-MM-DD")}}2025-01-23
if{{if(1.price > 80; "High"; "Normal")}}High

Automation Templates

Template 1: Morning Market Briefing

Send a formatted market summary every weekday morning.

Modules:

  1. Schedule: Every weekday at 7:00 AM
  2. HTTP: GET /v1/prices/latest
  3. JSON Parse: Parse response
  4. Text Aggregator: Format summary
  5. Email/Slack: Send briefing

Template 2: Weekly Price Report to Google Sheets

Track weekly averages and trends.

Modules:

  1. Schedule: Every Monday at 6:00 AM
  2. HTTP: GET /v1/prices/past_week?by_code=BRENT_CRUDE_USD
  3. JSON Parse: Parse response
  4. Iterator: Loop through prices
  5. Math Aggregator: Calculate average
  6. Google Sheets: Add row with date, high, low, average

Template 3: Threshold Alert System

Alert team when prices cross critical thresholds.

Modules:

  1. Schedule: Every 30 minutes
  2. HTTP: GET /v1/prices/latest?by_code=WTI_USD
  3. JSON Parse: Parse response
  4. Router with filters:
    • Path A: Price > $90 → Critical Alert
    • Path B: Price > $80 → Warning Alert
    • Path C: Price < $70 → Low Price Alert

Template 4: Database Sync

Sync oil prices to your database for analysis.

Modules:

  1. Schedule: Every hour
  2. HTTP: GET /v1/prices/latest
  3. JSON Parse: Parse response
  4. Iterator: Process each commodity
  5. PostgreSQL/MySQL: Insert/Update records

Troubleshooting

Scenario Execution Errors

Error: 401 Unauthorized

  • Verify your API key is correct
  • Check header format: Token YOUR_API_KEY (with space after "Token")

Error: 429 Rate Limited

  • Reduce execution frequency in scheduler
  • Check your OilPriceAPI plan limits

Error: JSON Parse Failed

  • Verify HTTP module received a valid response
  • Check that Content-Type is application/json

Debugging Tips

  1. Click on any module to see its output
  2. Use Run once frequently during development
  3. Check execution history for error details
  4. Enable Data Store to persist data between runs

Frequently Asked Questions

How do I authenticate OilPriceAPI in Make?

Authentication in Make uses the HTTP module with custom headers:

  1. Add an HTTP module (Make a request)
  2. In the Headers section, click Add item
  3. Set:
    • Name: Authorization
    • Value: Token YOUR_API_KEY

For reusable authentication:

  1. Go to Scenarios > Variables
  2. Create a variable named oilpriceapi_key
  3. In HTTP modules, use: Token {{variables.oilpriceapi_key}}

This makes it easy to update the key across all scenarios if needed.

What's the rate limit when using Make with OilPriceAPI?

OilPriceAPI limits depend on your plan: Free (1,000/month), Hobby (10,000/month), Starter (50,000/month), Professional (100,000/month). Configure Make schedules to stay within your limits:

PlanRecommended IntervalMonthly Requests
FreeEvery 6 hours~120
HobbyEvery hour~720
ProfessionalEvery 15 minutes~2,880

Use the Iterator module to process multiple commodities from a single API call, reducing your request count.

Can I automate price updates in Make?

Yes, Make offers flexible automation options:

Scheduled Execution:

  1. Click the clock icon on your trigger module
  2. Choose interval (minutes, hours, days)
  3. Set specific times if needed (e.g., weekdays only at 9 AM)

Webhook-Triggered:

  1. Use a Webhook trigger instead of scheduler
  2. Call the webhook URL from external systems
  3. Instant execution on demand

Conditional Scheduling:

  • Combine with Router modules to run different paths at different times
  • Use Filter to skip processing on weekends or holidays

What happens if the API call fails in Make?

Make provides robust error handling:

Built-in Retry:

  • HTTP modules automatically retry on certain failures
  • Configure retry settings in module options

Error Handlers:

  1. Right-click any module
  2. Select Add error handler
  3. Choose action:
    • Resume: Continue with default value
    • Rollback: Undo all changes in the scenario
    • Commit: Save partial results
    • Break: Stop and retry later

Error Notifications:

  • Add a parallel path for error alerts
  • Send Slack/email notifications on failure
  • Log errors to a Data Store for review

Common errors and solutions:

  • 401: Check API key format (Token YOUR_KEY with space)
  • 429: Add Sleep module between requests
  • Timeout: Increase timeout in HTTP module settings

How does Make compare to Zapier for oil price automation?

Make offers more visual workflow design, better data transformation capabilities, and more complex branching logic. It's ideal for users who need sophisticated data processing. Zapier is simpler for basic automations.

What's the cost to automate oil prices with Make?

Make offers a free tier with 1,000 operations per month. For hourly price checks to one destination, this covers about 700 executions. Paid plans start at $9/month for 10,000 operations.

Can I run scenarios on demand instead of on a schedule?

Yes. Use a Webhook trigger instead of a Scheduler. You can call the webhook URL from any system to trigger your scenario instantly.

How do I handle API rate limits?

Use Make's Sleep module to add delays between requests. For batch processing, add a 1-second sleep between iterations to stay within rate limits.

Can I store historical price data in Make?

Yes, use Make's Data Store feature to save price data. You can then query this data in other scenarios for trend analysis and reporting.