Make IntegrationBuild Powerful Delivery Automation with Make and UniHop
Connect UniHop to your existing tools through Make (formerly Integromat). Build multi-step automation scenarios that trigger delivery orders, handle routing logic, and process status updates — without writing code.
Overview
What Can You Build with Make + UniHop?
Make is a visual automation platform that lets you connect apps and build complex multi-step workflows without writing code. By calling the UniHop API through Make's HTTP module, you can integrate delivery dispatch into any workflow — processing orders from a database, routing deliveries based on business logic, handling retries on failure, and feeding delivery status back into downstream systems. Make's visual scenario builder makes it easier to build and maintain these workflows compared to writing custom code.
Setup
How to Build a UniHop Scenario in Make
Set Up Your Trigger Module
Start your scenario with a trigger that fires when a delivery should be created. Common triggers include a new row in Google Sheets or Airtable, a webhook received from your own system, a new record in a database, or a scheduled run that processes pending orders. Make supports hundreds of trigger apps natively.
Add Conditional Routing Logic (Optional)
Use Make's Router module to add conditional logic before submitting the order — for example, routing Standard delivery for orders under a certain distance, Special Handling for flagged items, or Oversize for orders above a weight threshold. This keeps business logic in the automation layer rather than hardcoded in your source system.
Call the UniHop API with an HTTP Module
Add an HTTP module configured as a POST request to https://backend.unihop.app/api/v1/orders. Map the pickup and drop-off address fields, delivery style, timing, and order reference from your trigger data. Include your UniHop JWT token in the Authorization header as a Bearer token. The response returns an order ID you can store for tracking.
Handle the Response and Status Events
Use Make's built-in error handling to manage failed API calls and retries. To receive delivery status updates, configure a Webhooks module in Make as the target for UniHop status events and add modules to process each status — updating records, sending notifications, or triggering downstream workflows when a delivery is confirmed.
Use Cases
Workflow Patterns for UniHop + Make
Multi-Step Order Processing
Make's scenario builder lets you chain together steps that a single webhook cannot handle — validate the order data, check delivery zone eligibility, select the right delivery style, submit to UniHop, and update your order management system in a single automated flow.
Batch Delivery Dispatch
Scheduled scenarios can pull a list of pending orders from a database or spreadsheet at a set time and submit them all to UniHop in sequence — useful for meal prep brands dispatching a batch day or florists processing the morning's delivery queue.
Cross-Platform Order Routing
Businesses that receive orders across multiple channels (website, phone, in-store POS) can consolidate them in Make and route all local delivery orders to UniHop from a single automation scenario, regardless of which channel the order came from.
Status-Driven Customer Notifications
When UniHop sends a delivery status webhook, Make can process it and trigger personalized customer notifications through your preferred channel — email via Gmail, SMS via Twilio, or push notifications through a connected app — with delivery details mapped from the event.
Requirements
What You Need
- A Make account (Core plan or above for HTTP module and advanced features)
- UniHop API credentials — contact the UniHop team to get your client ID and RSA key pair
- Basic familiarity with building scenarios in Make
- A trigger source connected to Make (Google Sheets, Airtable, a webhook, or another app)
FAQ
Frequently Asked Questions
Make offers more flexibility for complex, multi-step automation scenarios. While Zapier is well-suited for simple trigger-to-action workflows, Make's visual scenario builder handles conditional routing, loops, error handling, and multi-branch logic without additional complexity. For businesses with more advanced dispatch workflows — routing logic, batch processing, or status-driven branching — Make is typically a better fit.
UniHop does not currently have a dedicated Make module. The integration uses Make's HTTP module to call the UniHop REST API directly. This gives you full access to all UniHop API endpoints — create order, get quote, cancel order, check availability — without being limited to actions exposed in a pre-built module.
JWT tokens used for UniHop authentication have an expiration time set when the token is signed. In Make, you can manage token refresh by storing the current token in a Make data store and adding a step at the start of your scenario to check whether the token is still valid before making API calls. The UniHop team can advise on recommended token lifetimes for automation scenarios.
Yes. Make's HTTP module works well for testing API calls interactively. You can build a simple scenario with a manual trigger and a single HTTP call to test order creation, get a quote, or check service availability before building out the full automation logic.
Make has built-in error handling that you can configure at the module level — retry the call, stop the scenario, or route the failed record to an error-handling path for manual review. For production delivery workflows, it is worth configuring an error branch that alerts your team when an order fails to submit so it can be dispatched manually.
Ready to build delivery automation with Make?
Contact the UniHop team to get your API credentials and start building your first scenario.
Talk to Our Team