Flow HTTP Requests or a Real Integration Build on Shopify?
Flow HTTP integration is a CUSTOMIZE for a handful of one-off calls. Send HTTP Request runs on the Plus, Advanced and Grow plans and waits a maximum of 30 seconds for a response code. Retry, Fail or Ignore is selectable per 4XX and per 5XX or 429 response, with retry lasting up to 24 hours. Parsing the body with Run code is optional, not required.
Your profile — see how the verdict shifts
- Confidence
- High — Read Shopify's Send HTTP Request reference: the action is only available to the Shopify Plus, Advanced, or Grow plans; after Flow sends the request it waits for a maximum of 30 seconds for an HTTP response code; and the On 4XX response and On 5XX or 429 response fields each offer one of three selectable behaviors, Retry, Fail or Ignore, where Retry runs for up to 24 hours until receiving a different response code or timing out (verified Sep 2026). The same page frames a Run code step as an optional way to parse the body of the response, so a one-way push needs no code step at all. Read the monitoring page: workflow runs are stored for 14 days, then removed, which is the observability ceiling on any integration built this way. Fetched both App Store listings: Zapier at 3.7★ across 56 reviews and Make at 1.0★ across 3 reviews, a review base too thin to lean on. Checked Workato: it publishes no Shopify App Store listing, because its Shopify connector is configured inside Workato's own platform rather than installed on the store.
- Reference scenario
- $20M–$500M GMV · Shopify Plus · an ERP, a WMS and a finance system with no Flow tasks of their own · a few thousand orders a week · an internal API team available for anything beyond a single call
- As of
- September 2026
Decision at a Glance
| Your profile | Verdict | Why |
|---|---|---|
| One or two fire-and-forget notifications | WAIT | Posting an order event to a webhook receiver is exactly what Send HTTP Request was built for. Set the 4XX and 5XX behavior, and you're done for free. |
| A handful of one-way pushes to one system | CUSTOMIZE | Five or six calls stay maintainable inside Flow, provided each receiving endpoint acknowledges inside the 30-second wait and the retry behavior is set deliberately rather than left at the default. |
| Two-way sync across several systems | BUY | Flow has no inbound endpoint, so anything the ERP needs to push back arrives outside Flow entirely. An iPaaS covers both directions and brings its own run history past Shopify's 14 days. |
| Order-critical ERP or WMS integration at volume | BUILD | Ordering, idempotency, replay and backpressure are middleware concerns. A workflow step that retries for up to 24 hours will happily deliver events out of order while it does. |
What Flow HTTP Integration Actually Drives
| Outcome | Impact | How it works |
|---|---|---|
| Operational efficiency | High | Orders, refunds and inventory changes reach the ERP without anyone rekeying them, which is the entire reason the first HTTP step gets built. |
| Data & insight | High | A payload log you keep turns every integration question into a query, while Flow's run history answers only the last 14 days. |
| Revenue — indirect | Medium | Stock and pricing that reach downstream systems late cause oversells and stale listings, which cost sales that never appear as an error anywhere. |
| Customer experience | Medium | A fulfillment record that never reaches the warehouse shows the customer a shipment that has not moved, and support finds out before operations does. |
Spend ceiling: Spend nothing until the sixth call. Send HTTP Request is included on the Grow, Advanced and Plus plans, and it covers one-way pushes properly. Reserve the $20,000–$60,000 build (Deploi estimate, illustrative) for traffic where a dropped or duplicated event costs money.
What buying enables (top apps)
- + Connectors to hundreds of systems with the authentication and pagination already solved
- + Two-way sync, which Flow cannot do at all because it has no inbound endpoint
- + Run history and error dashboards that outlast Shopify's 14-day retention
- + A working integration in days rather than the quarter a middleware build takes
What building additionally unlocks
- + Ordering and idempotency, so a retried event never lands twice or out of sequence
- + Replay from a payload log you keep as long as you want
- + Receivers that acknowledge instantly and work asynchronously, free of the 30-second wait
- + No task metering, so integration cost stops tracking order volume
Find Your Verdict in 3 Questions
Is your store on the Plus, Advanced or Grow plan?
Yes: Go to question 2.
No: Your verdict: BUY — Send HTTP Request is unavailable below Grow, so an iPaaS or a custom app is the only path out of Shopify.
Are the calls one-way, and does each receiver acknowledge inside 30 seconds?
Yes: Go to question 3.
No: Your verdict: BUILD — put a queue in front of your own endpoint so it acknowledges immediately and works asynchronously.
Would a dropped, duplicated or out-of-order event cost real money?
Yes: Your verdict: BUILD — ordering, idempotency and replay are middleware jobs that a 24-hour retry cannot do.
No: Your verdict: CUSTOMIZE — keep the calls in Flow, set the 4XX and 5XX behavior deliberately, and revisit once there are more than about six.
The TCC Scorecard — 12 Dimensions
TCC — Total Cost of Capability: what it actually costs to have this capability over three years, whichever way you get it. Each dimension is scored 0–5 for both paths. How we score →
| Dimension | Buy | Build | Why |
|---|---|---|---|
| Cost | |||
| Acquisition & implementation | An iPaaS connects in days; real middleware runs an estimated 8–16 weeks (Deploi estimate, illustrative) before the first system is live. | ||
| Recurring fees | iPaaS platforms meter tasks or operations, so the bill tracks order volume; a Flow step and your own service do not. | ||
| Maintenance & upgrades | Vendor-maintained connectors versus your own retry, queue and schema-change handling, which someone has to own permanently. | ||
| Switching & exit | Recipes and mappings built in an iPaaS console do not export; a service you wrote moves to any host with the contract intact. | ||
| Risk | |||
| Vendor risk | Zapier's listing carries 3.7★ across 56 reviews and Make's 1.0★ across 3, and Workato has no App Store listing at all. | ||
| Security & compliance surface | An iPaaS holds order and customer payloads in a third-party cloud; a direct call from Flow to your own endpoint has one fewer hop. | ||
| Platform-deprecation exposure | The plan gate on Send HTTP Request is the exposure worth watching, since dropping below Grow removes the action entirely. | ||
| Value | |||
| Fit to requirement | One-way pushes fit the Flow action exactly; ordering guarantees and two-way sync fit only a service you control. | ||
| Time to market | A single HTTP step ships in an hour, an iPaaS recipe in days, and middleware in a quarter. | ||
| Performance & scale | The 30-second wait caps what any synchronous endpoint can do; a queue in front of your service removes that ceiling. | ||
| Data ownership & AI-readiness | Flow keeps run history 14 days and an iPaaS keeps it in its own console; your own service logs every payload where you can query it. | ||
| Focus & opportunity cost | Building integration plumbing is a real project, and the first two calls almost never justify starting one. | ||
The App Landscape
| App | Status | Pricing | Best for |
|---|---|---|---|
| Shopify Flow (Send HTTP Request) | Native — First-party Shopify app. The Send HTTP Request action is only available to the Shopify Plus, Advanced, or Grow plans. Flow waits a maximum of 30 seconds for an HTTP response code, and the On 4XX and On 5XX or 429 fields each offer Retry, Fail or Ignore, where Retry runs for up to 24 hours until a different response code arrives or the request times out. Parsing the response body with a Run code step is optional. | Included on the Grow, Advanced and Plus plans; Flow itself is free from Basic upward (verified Sep 2026) | A handful of one-way calls to systems that have no Flow tasks of their own |
| Zapier: Workflow Automation | Live — 4.0★, 74 reviews; 14-day trial on Professional and Team. Generic middleware connecting Shopify to other SaaS tools; the free tier allows two-step Zaps, and paid tiers add multi-step Zaps and webhooks. Logic lives in Zapier's editor, and the Shopify listing's rating trails Mechanic's. | Free (two-step Zaps); Professional $29.99/month; Team $103.50/month (verified Sep 2026) | Connecting Shopify events to SaaS tools without writing or hosting anything |
| Make | Live — flagged — 1.0★ across 3 reviews on the Shopify listing, which is far too thin a review base to judge the app on. Make's own platform is a mature visual iPaaS, so treat the listing as an install path and evaluate the platform on its own trial rather than on these reviews. | Free tier available; Core $10.59/month; Pro $18.82/month; Teams $34.12/month (verified Sep 2026) | Visual multi-step integrations where the logic belongs outside Shopify |
| Owned integration service | Build lane — A queue in front of your own endpoint, called by Flow or by Shopify webhooks, that acknowledges immediately and does the work asynchronously. Adds ordering, idempotency, replay and a payload log that outlives Flow's 14-day run history. Warranted when the integration is order-critical rather than convenient. | $20,000–$60,000 one-time plus roughly 15–20% a year in upkeep (Deploi estimate, illustrative) | ERP and WMS integrations where a dropped or duplicated event costs money |
The Build Path
- Start with the action alone: Send HTTP Request covers a one-way push with no code at all. Set the On 4XX and On 5XX or 429 behavior deliberately: Retry runs for up to 24 hours until a different response code arrives or the request times out, while Ignore lets a failure pass silently (verified Sep 2026).
- Parse only when a later step needs a field: Shopify frames the Run code step as an optional way to parse the response body, so a fire-and-forget call needs none. When you do parse, the code step is bounded by 5 seconds, 10MB and a 5,000-character output data schema (verified Sep 2026).
- Design the receiver around the 30-second wait: Flow waits a maximum of 30 seconds for a response code, so the endpoint should acknowledge immediately and do the real work asynchronously. An ERP that takes a minute to post a document will fail the step even when the document eventually lands correctly.
- Move to middleware for ordering and replay: A 24-hour retry delivers events out of order while it retries, and Flow removes run history after 14 days. Ordering, idempotency keys, replay and a payload log are the things a queue in front of your own service buys, and no Flow step provides them.
- Effort band
- $20,000–$60,000 build — Deploi estimate (illustrative); lands in the $25–75K contact-form band. One queue and one system integration sits at the bottom; three systems with two-way sync, replay and reconciliation sits at the top
- Typical timeline
- 8–16 weeks (Deploi estimate, illustrative): about three weeks for the queue and the first endpoint, the rest for mapping, replay tooling and reconciliation
- Maintenance, honestly
- ~15–20% of build cost per year (Deploi estimate): roughly $3,000–$12,000/yr (Deploi estimate, illustrative) for hosting, schema changes on the ERP side and Admin API version bumps. Flow's HTTP action adds no fee on plans that include it.
- What you own — and what you take on
- You own: the queue, the mappings, the replay tooling and a payload log that outlives Flow's 14 days. You take on: hosting, credential rotation, and the contract with every system on the other side of the wire.
3-Year Total Cost of Capability
| Buy (app path) | Build (custom path) | |
|---|---|---|
| Year 0 (setup) | $8,000–$25,000 (recipe build and mapping) | $20,000–$60,000 |
| Years 1–3 (recurring) | $7,200–$28,000 (metered subscription) | $9,000–$36,000 (hosting and maintenance) |
| 3-year total | ≈$15,200–$53,000 | ≈$29,000–$96,000 |
- † All figures illustrative samples for the reference scenario — not quotes, not verified pricing.
- † Buy path: an iPaaS on a team-sized plan, modeled above Zapier's published Team price of $103.50/month (verified Sep 2026) because task metering rises with order volume.
- † Build path: one queue, two system integrations, replay tooling and a daily reconciliation job; three-year horizon; ERP-side work excluded from both lanes.
What the Sticker Price Hides
On the buy path
- — Task-metered pricing scales with order volume, so the quote you approve is priced on today's throughput
- — Not every iPaaS ships a Shopify App Store listing: Workato configures its Shopify connector inside its own platform instead, so procurement and support live off-platform
- — Recipes and field mappings built in a vendor console do not export, so a switch means rebuilding them
- — Make's Shopify listing carries only 3 reviews, so judge the platform on a trial rather than on the listing
On the build path
- — The 30-second wait means a slow receiver fails the step even when the downstream work eventually succeeds
- — A 24-hour retry delivers events out of order while it retries, which is a correctness problem, not a delay
- — Flow's 14-day run history is not an audit trail, so the payload log has to be part of the build
- — Roughly $3,000–$12,000/yr in hosting and upkeep (Deploi estimate, illustrative) that no subscription line makes visible
What Merchants Say
Integration leads describe the quiet drift: a handful of HTTP steps grows into the real integration, and nobody notices until an endpoint changes and four workflows break at once.
Middleware reviews cluster on metering and visibility: the task bill climbs with order volume, and the run history that would explain a missing record sits in a second console.
If You Change Your Mind Later
If you bought and outgrow it
Recipes, connectors and field mappings built in an iPaaS console leave as screenshots rather than as configuration, so budget a rebuild. Export the run history and the mapping documentation while the contract is live, because reconstructing which field went where is the expensive part of any migration.
If you built and want out
Nothing is stranded: the queue, the mappings and the payload log are yours, and the endpoints can be called from Flow, from webhooks or from anything you add later. Moving back to an iPaaS is easy too, because the contract with each system is already written down.
When This Answer Changes
We're watching for:
- ▸ Any change to the Plus, Advanced and Grow plan gate on Send HTTP Request
- ▸ Changes to the 30-second response wait or the 24-hour retry ceiling, both current as of September 2026
- ▸ A native inbound endpoint in Flow that accepts events from outside systems, which would close the one-way gap
Verdict change log:
No changes since first publication (September 2026).
Common Questions
Which Shopify plans can use Flow's Send HTTP Request action?
Shopify limits the action to the Plus, Advanced and Grow plans. Flow itself is a free app from Basic upward, so a Basic store can automate inside Shopify but cannot call an outside system from a workflow. On an eligible plan the action waits a maximum of 30 seconds for a response code. Confirm the plan before scoping any integration around it.
What happens when the endpoint returns an error?
You choose. Flow gives three selectable behaviors, Retry, Fail or Ignore, set separately for a 4XX response and for a 5XX or 429 response. Retry runs for up to 24 hours until a different response code arrives or the request times out. Flow waits a maximum of 30 seconds for that response code in the first place.
Do I need a Run code step to read the HTTP response?
No. Shopify's own reference describes a Run code action as an optional way to parse the body of the response, so a one-way push needs no code at all. Add the step only when a later action needs a field from the body. Run code then applies its own limits: 5 seconds, 10MB, and a 5,000-character output data schema.
Your Next Steps
If you're going with CUSTOMIZE(matches your selected profile)
- List every workflow that already calls an outside system, and name the receiver for each
- Set the On 4XX and On 5XX or 429 behavior explicitly on each step rather than leaving a default
- Confirm each receiver acknowledges inside Flow's 30-second wait, under real load
- Add a Run code step only where a later action needs a field from the response body
- Log the outcomes outside Shopify, since Flow removes run history after 14 days
- Set a threshold now: past roughly six calls, re-open this decision
If you're going with BUILD
- Write the contract for each system first: payload, ordering guarantee, idempotency key, failure behavior
- Put a queue in front of your endpoint so it acknowledges immediately and works asynchronously
- Keep a payload log you can replay, which Flow's 14-day run history cannot give you
- Run a daily reconciliation between Shopify and the ERP rather than trusting delivery
- Cut over one system at a time and leave the Flow step disabled, not deleted, for a fortnight
Official Docs & Sources
- Send HTTP Request action: plans, timeout and error behavior — Shopify Help Center
- Run code action: limits for optional response parsing — Shopify Help Center
- Shopify Flow plan availability — Shopify Help Center
Official documentation linked for verification — our verdicts and estimates are our own.
Related Decisions
Should You Build or Buy a Historical Order Export Tool?
Shopify emails any order export past 50 orders and estimates 400,000 items at around 4 hours. The mechanics are identical on every plan, Plus included.
Are Bulk Operation Timeouts a Platform Ceiling or Your Bug?
A Shopify bulk query allows five total connections, two levels of nesting and 10 days to finish (verified Sep 2026). Plus raises none of the three.
How Many Bulk Operations Can Run at Once on Plus?
Each app gets up to five simultaneous bulk query operations per shop on API 2026-01 and higher (verified Sep 2026). Separate apps never share one slot.
Will the Storefront API Hold Up on Your Next Flash Sale?
Shopify says real-buyer requests face no fixed per-minute limit on the Storefront API. The ceiling is checkout creation, and it fails with a 200, not a 429.
Should You Build or Buy a PIM on Shopify?
PIM on Shopify is a scale decision: metafields cover most catalogs, PIM apps win at multi-channel breadth, custom pipelines at ERP-grade complexity.
Has a handful of HTTP steps become your integration?
We map what each workflow actually calls, keep the one-way pushes in Flow, and put the order-critical traffic behind a queue with replay and a payload log.
Contact us todayVerdict scored for the reference scenario above. Estimates are not quotes; app pricing carries its verification date and gets re-verified quarterly. The plan gate, response wait and retry ceiling are published on Shopify's own action reference and can change, so confirm the current figures before you design around them.
Read how we score these decisions (the TCC Framework). No affiliate links, no paid placement — no app vendor pays to appear here.