Contents
- Verdict
- What is Pipedream?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with Pipedream
- What Pipedream actually costs at small-business volume
- The gotchas: unpublished tiers, hard timeouts, and an acquisition
- What breaks in production, and how you find out
- What it connects to that you already run
- Pipedream alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
For developers, Pipedream is one of the most capable automation platforms available, and its credit model is one of the fairest at volume - Pipedream's documentation defines a credit as 30 seconds of compute at the default 256MB of memory, which means a fast workflow costs a fraction of a credit's worth of time regardless of how many steps it contains. That is a fundamentally better deal than per-task billing for anything that runs quickly. Two caveats a buyer should weigh: we could not read Pipedream's current plan tiers off a publicly accessible pricing page as of August 2026, and Workday agreed to acquire the company, which makes long-term pricing direction a reasonable thing to ask about before signing an annual contract.
What is Pipedream?
Pipedream is a workflow automation platform aimed at developers, combining no-code triggers and actions with the ability to drop into Node.js or Python whenever you need real code. It connects to thousands of apps and manages the auth for you. Its MCP server is one of the most widely deployed anywhere, exposing the full integration catalog as tools for AI agents, and Workday agreed to acquire the company in late 2025.
Best for
Developers who want managed integrations and auth but full code control inside workflows.
Not for
Non-technical operators who never want to see a line of code. Pipedream has pre-built actions, but its actual value is the code step, and workflows that avoid code entirely are better served by a purpose-built no-code tool.
Strengths
- Credits bill compute time, not actions, so a fast twenty-step workflow can cost less than a slow two-step one
- Code steps in Node.js and Python make almost anything possible without leaving the platform
- Thousands of app integrations with OAuth token management handled for you, which is the genuinely tedious part of building integrations
- Its MCP server is one of the most widely deployed anywhere, exposing the whole catalogue as tools for AI agents
- Development and test runs do not consume production credits, so iterating is free
- Open-source component registry you can read, fork and extend rather than treat as a black box
- Covers the small-business stack plus a very long tail of developer and SaaS APIs
Limitations
- Built for developers; a non-technical user will hit the ceiling almost immediately
- Compute-time billing is hard to forecast for slow steps - an API that occasionally takes eight seconds costs eight times one that takes one
- Daily free credits do not roll over, which penalises bursty rather than steady workloads
- Current paid tier pricing was not readable from a public page as of August 2026, which complicates budgeting
- The Workday acquisition introduces real uncertainty about long-term product direction and pricing
- Raising memory allocation to fix a slow step multiplies credit consumption proportionally, so performance problems become billing problems
Pipedream pricing
Pipedream meters credits tied to compute time. Its documentation states the rate plainly: one credit per 30 seconds of compute at 256MB of memory per workflow execution, with credit usage scaling proportionally if you raise the memory allocation. That means cost tracks how long your code runs, not how many steps you drew or how many records you touched - a structural advantage over per-task billing for short workflows and a structural disadvantage for slow ones. There is a free tier with a daily credit allowance and a limited number of connected accounts. We could not read the current paid plan names and prices from a publicly accessible pricing page as of August 2026, so check them directly rather than budgeting from a figure you saw quoted elsewhere.
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | Daily credit limit that cannot be exceeded and does not roll over; limited active workflows and connected accounts; Connect in development mode only; community support |
| Paid plans | Not published | A platform fee plus a pool of included credits. Names and prices did not render on a publicly readable page as of Aug 2026, so we do not quote them |
| Business | Not published | The one paid tier Pipedream's docs name by title: payment by invoice rather than card is available on the Business plan |
| Additional credits | Metered | Paid tiers are uncapped on credits and compute time, with usage above the included pool billed at the start of the next period; you can set a manual usage cap |
| Credit definition | 1 credit | = 30 seconds of compute at 256MB per execution; 1024MB costs 4 credits for the same 30 seconds. Unused credits never roll over on any tier |
Pricing reflects public plans as of August 6, 2026 and can change. Check Pipedream for the latest.
What people actually build with Pipedream
Pipedream is a code-first platform wearing an integration platform's clothes, and the work that suits it reflects that. The pre-built triggers and actions get you to the first working version quickly; the code step is why you stay.
Inbox triage with real parsing. An email trigger receives the message, a Node.js step strips quoted replies and signatures, an OpenAI or Claude call classifies and extracts the fields that matter, and a final step writes to the CRM. The parsing that would be six modules and a regex on a visual canvas is eight lines of JavaScript here, and the whole run finishes inside a second, which on a compute-time meter means it costs almost nothing.
Webhook fan-out and normalisation. Several upstream systems send differently shaped payloads to one endpoint; a code step normalises them into a single internal schema and routes onward. This is the job every growing business eventually has and no visual builder handles gracefully.
Scheduled data pulls that need pagination. A cron trigger runs nightly, a code step walks a paginated REST API until it runs out of pages, and the result is written to a warehouse table. Pagination loops are where drag-and-drop builders become genuinely painful and where twelve lines of code are simply correct.
An MCP layer for an internal assistant. Pipedream's MCP server exposes its whole integration catalogue as callable tools, so an assistant like Claude can act across your business systems without anyone building an integration layer first. For a technical team wanting an agent that does things rather than talks about them, this removes what used to be the expensive half of the project.
Backend glue for a product. Because credentials are managed for you, Pipedream is a reasonable place to run the OAuth-heavy integrations your own application needs, rather than building token refresh yourself for the fifth time.
What Pipedream is genuinely bad at: long-running work, and non-technical ownership. Executions default to 30 seconds for HTTP and email triggers and 60 for cron, and the hard maximum is 300 seconds on free and 750 seconds on paid - so any job that genuinely takes more than about twelve minutes must be decomposed into queued segments before you build it, not after. And a business whose automation champion is the office manager will not get value here, because almost every non-trivial workflow ends in a code step by design.
Bottom line: Pipedream suits fast, code-shaped work - parsing, normalisation, pagination, MCP tooling - and is structurally wrong for long-running jobs, because the hard execution ceiling is 750 seconds even on paid plans.
What Pipedream actually costs at small-business volume
Pipedream is the only major platform in this directory that bills for time rather than for things. Its documentation defines a credit as 30 seconds of compute at the default 256MB of memory per workflow segment, and raising the memory allocation raises credit consumption proportionally. So the question that determines your bill is not how many steps you drew or how many records you touched - it is how long your code takes to finish.
That is transformative for the common case. Our standing workload - 2,000 runs a month, six steps - completes in a couple of seconds per run on a platform like this, which means it sits inside the minimum billing increment and costs roughly 2,000 credits a month. The identical work is around 12,000 billable units on a per-step platform. If you have not internalised why the same automation produces such different bills on different products, that is the entire point of automation billing units.
It inverts for slow work. A workflow that waits on a sluggish third-party API for forty seconds burns two credits per run, and one that processes a large file for five minutes burns ten. On a per-task platform those would all cost the same. So Pipedream is unusually cheap for high-volume, fast automations and unusually expensive for low-volume, slow ones - which is the opposite of almost everything else here, and worth checking against your actual workload before assuming either way.
Two useful details on top. Development and test runs do not consume production credits, so iterating is genuinely free rather than nominally free. And memory is a cost dial you control: the default 256MB is enough for most integration work, and raising it towards the 10GB maximum buys proportionally more CPU at proportionally more credits.
| Scenario | Memory | Time per run | Credits per run | Credits at 1,000 runs/mo |
|---|---|---|---|---|
| Fast integration workflow | 256MB (default) | Under 30s | 1 | 1,000 |
| Waiting on a slow API | 256MB | 40s | 2 | 2,000 |
| File processing | 256MB | 5 min | 10 | 10,000 |
| Memory raised to fix a slow step | 1024MB | Under 30s | 4 | 4,000 |
| Development and test runs | Any | Any | 0 | 0 |
What we re-verified, and what still is not published
Re-checked on 2026-08-06 against Pipedream's own documentation at pipedream.com/docs/pricing and its pricing FAQ. The credit definition holds: one credit per 30 seconds of compute at 256MB, and running a workflow at 1024MB costs four credits for the same 30 seconds because you are using four times the default memory. Unused credits do not roll over on either the free or the paid tiers. Paid tiers have no cap on credits or compute time - you can run any volume, with usage charges applying above the included pool, and you can set a manual usage cap yourself if you want to bound the exposure.
What still does not exist publicly is a readable list of plan names and prices. pipedream.com/pricing renders as an application shell rather than content, and the documentation explicitly defers plan prices to that page. Third-party write-ups quoting Pipedream tiers disagree with each other, which is precisely why none of them are repeated here. Read the tiers off the live page in your own browser before you commit to anything annual.
How to forecast a bill you cannot look up
You can still model this accurately, because the unit is knowable even when the price is not. Build the workflow, run it fifty times on real data, and read the compute time from the usage dashboard. That gives you credits per run. Multiply by expected monthly runs and you have your credit consumption, which is the only number you need to take into a pricing conversation. Do the same measurement again after any change that adds an external API call, because a third-party endpoint degrading from one second to eight multiplies that workflow's cost eightfold with no other symptom.
Bottom line: One credit is 30 seconds of compute at 256MB, so raising a workflow to 1024MB to fix a slow step quadruples its cost for identical work - performance tuning on Pipedream is a billing decision.
The gotchas: unpublished tiers, hard timeouts, and an acquisition
First, the honest gap. As of August 2026 Pipedream's pricing page did not render readable plan information to us - the page returned an application shell rather than content - and its documentation explicitly defers plan prices to that page. Third-party summaries of Pipedream's tiers exist and they disagree with each other on both plan names and prices, which is exactly why we are not going to repeat any of them. We can tell you the unit with confidence because the documentation states it; we cannot tell you the plan prices, and you should read them off the live pricing page yourself rather than trusting any figure you find quoted elsewhere.
Second, timeouts, which are the limit people actually collide with. Pipedream defaults to 30 seconds per execution for HTTP and email triggers and 60 seconds for cron triggers. The maximum you can raise that to is 300 seconds on the free tier and 750 seconds - twelve and a half minutes - on paid. That is a hard ceiling, not a soft one, and it means any job genuinely longer than about twelve minutes has to be decomposed into queued segments rather than run in one pass. Design for that from the start; retrofitting it is painful.
Third, and this is a commercial rather than technical consideration: Workday announced a definitive agreement to acquire Pipedream in November 2025, with both companies stating they would continue operating independently until the deal closed. We could not confirm from a public source whether it has completed as of August 2026. That is not a reason to avoid the platform, but it is a fair thing to raise before signing an annual contract - ask about pricing and roadmap commitments, and get the answer in writing.
Fourth, a small one that penalises the wrong shape of business: the free tier's credit allowance resets daily and nothing rolls over, on free or paid. A workload that would fit comfortably inside a monthly figure but arrives in bursts - end of month invoicing, a Monday morning flood - hits a daily wall that a monthly allowance would have absorbed.
Bottom line: Pipedream's plan prices still do not render on any publicly readable page, so the only honest way to budget is to measure your own credits per run and take that number to the vendor.
What breaks in production, and how you find out
Payload size is the first wall, and it is smaller than people expect. HTTP triggers accept 512KB by default, expandable using special headers for large payloads; email triggers take 30MB; logs and exports combined are capped at 6MB; and workflow disk at /tmp is 2GB and cannot be raised. The 6MB log-and-export cap is the sneaky one - a workflow that logs verbosely while handling a decent-sized response can fail on the logging rather than on the work.
Throughput is documented as an average of 10 requests per second for HTTP endpoints, with an allowance for brief bursts, and paid customers can request an increase through support. Ten per second is generous for a small business and immediately insufficient for a webhook firehose, so if you are receiving events from a high-volume source, ask for the increase before you launch rather than after you have dropped a day of events.
Retention is the other operational number to plan around. The free tier retains 7 days of events, paid retention varies by plan, and execution details expire after 365 days. So your debugging window on free is a week, and your absolute audit ceiling is a year. If you need to prove what happened in a dispute after that, write your own record into a system you own as a step in the workflow.
The failure mode particular to a code-first platform is worth naming: what breaks is usually a dependency or an unhandled edge case in your own code step, not the platform. That is a fair trade for the power, but it means Pipedream projects need the discipline software projects need - error handling around external calls, and an alert when a workflow starts throwing - rather than the discipline a no-code tool needs.
Cost is a monitoring signal here, not just a bill
On a per-task platform, a slow third-party API is a latency problem. On Pipedream it is a cost problem too, and that is genuinely useful if you watch the right number. Track credits per run rather than runs per month, and a dependency that has quietly degraded shows up in your billing dashboard before anybody complains. Set the manual usage cap that Pipedream's documentation says paid workspaces can configure, and you have both an alert and a bound on the damage.
The corollary is that the fix for a slow step is often architectural rather than a memory bump. Raising memory to 1024MB quadruples the credit cost of every run; adding retry logic with a sensible backoff around a flaky call, or moving a slow enrichment into a separate queued workflow, usually costs nothing.
Treat the code steps as software
The single biggest difference between a Pipedream workflow that survives a year and one that does not is whether anyone applied ordinary engineering habits to it. Wrap every external call in error handling, make writes repeatable so a retry cannot double-charge a customer, keep the code in version control rather than only in the editor, and put tracing and logging around the parts you will one day need to explain. None of this is exotic. It is simply that Pipedream, unlike a no-code builder, will happily let you ship something fragile.
Bottom line: On a compute-time meter a degrading third-party API shows up as a rising bill before anyone complains, which makes credits per run the most useful production alert Pipedream gives you.
What it connects to that you already run
Pipedream's catalogue runs to thousands of applications and covers both the mainstream small-business stack and a very long tail of developer-facing APIs. The genuinely valuable part is not the count, though - it is that Pipedream manages OAuth token acquisition and refresh for you across all of them. Credential handling is the most tedious and most breakable part of building an integration by hand, and having it solved is worth more than another five hundred logos.
Google Workspace, Microsoft 365, Slack, HubSpot, Salesforce, Stripe, Shopify, Airtable, Notion, GitHub and the common databases are all present, alongside the sort of niche developer APIs a no-code tool would never bother with. Because every workflow can drop into a Node.js or Python code step, an unsupported API is a mild inconvenience rather than a blocker - you write the fetch call and move on.
Its MCP server is among the most widely deployed anywhere, which means the whole integration catalogue can be exposed as callable tools to an AI assistant. For a technical small business wanting an agent that can genuinely act on its systems, that is a shortcut worth a great deal, and it is a capability most no-code platforms are still catching up to.
Bottom line: The catalogue count is not the point: Pipedream managing OAuth acquisition and refresh across thousands of apps removes the most breakable part of building any integration by hand.
Pipedream alternatives: what to pick instead, and when
Pipedream's two defining traits are compute-time billing and a code-first builder. Every alternative below trades one of those away, and which trade is right depends almost entirely on who is doing the building and how long your workflows run.
Pick n8n instead if you want a published price and the option to self-host. Its per-execution meter is simpler to forecast than compute time, its price list is public, and it can run on hardware you control, which is the answer to a data-residency requirement Pipedream cannot meet at any tier. You give up managed OAuth depth and the comfort of writing plain Node.js or Python without a node wrapper around it. For most small businesses this is the one to compare against.
Pick Make.com instead if the person building is not a developer. This is a change of category rather than a swap: you get a canvas anyone can read and lose the code step that was the point of Pipedream. It is also a worse meter for anything step-heavy, since Make bills per module action.
Pick Zapier instead only if the deciding factor is a niche connector nobody else supports and there is no developer available. It is far more expensive at the reference workload and much less capable, and it will be live sooner.
Pick Activepieces instead if you want an open-source platform you can host yourself with a published credit table. A flow run costs one credit regardless of steps, the community edition is MIT-licensed, and the integrations double as MCP servers much as Pipedream's do. The catalogue is far thinner and there is no real equivalent to Pipedream's code-step maturity.
One thing worth weighing that is not a feature comparison: Workday's agreement to acquire Pipedream makes long-term pricing direction a fair question to ask, and an open-source alternative you can run yourself is the cleanest hedge against any answer you do not like.
| Platform | Billing unit | Reference workload | Realistic monthly cost | Suits | Does better than Pipedream |
|---|---|---|---|---|---|
| Pipedream | 1 credit per 30s compute at 256MB | ~1,000 credits if runs finish inside 30s | Plan prices not published | Developers wanting managed OAuth | - |
| n8n | 1 execution per whole run | 1,000 executions | 20 EUR (~$23) on Starter, or ~$15 hosting self-hosted | One technical owner, data control | Published price, self-hosting |
| Make | 1 credit per module action | ~5,000 credits | $9 on Core (10,000 credits included) | Non-technical builder, visual logic | A canvas a non-developer can read |
| Zapier | 1 task per successful action | ~5,000 tasks | $89 annually, $133.50 monthly on Professional | Obscure app, no technical staff | Connector catalogue breadth |
| Activepieces | 1 credit per run, 2-20 per AI call | 1,000 run credits plus AI credits | $20 on Plus, or ~$15 hosting self-hosted | Open source, simple builder | MIT licence, self-hosting, published rates |
Bottom line: Pipedream is the cheapest option here for fast, high-volume work and the only one whose price you cannot look up, which is why n8n is the comparison most small businesses should actually run.
Migration and lock-in: can you get your work out?
Pipedream sits in an unusual middle position on lock-in and it is better than it first appears. The most valuable part of what you build here is your own code, in Node.js or Python, in standard files - and that runs anywhere. A workflow that fetches, transforms and posts is portable to any environment that runs the same language, which is a materially different situation from a proprietary visual canvas whose logic exists only inside the vendor's editor.
The component registry is open source, so the pre-built actions and sources you depend on can be read, forked and extended rather than treated as a black box. If you need to know exactly what an integration does before you trust it with customer data, you can go and look.
What does not travel is the platform glue: the trigger configuration, the credential connections, the scheduling and Pipedream's own workflow structure. Those get rebuilt if you move. There is no self-hosted edition, so data residency is not something you can control, and the acquisition noted above adds a governance question a cautious buyer should ask about rather than assume away. The sensible hedge for anything important suits a code-first platform anyway: keep your logic in version control rather than only in the editor, so the valuable half of the work already lives outside the vendor.
One practical detail that decides how bad a migration feels: how much of your code leans on Pipedream's own helpers. A step that uses `this.$auth` and platform-specific exports is Pipedream code. A step that takes inputs, calls fetch and returns a value is JavaScript. Writing the second kind where you reasonably can costs nothing today and turns a migration from a rewrite into a re-wiring.
Bottom line: Your code steps are ordinary JavaScript or Python that runs anywhere, so what you would actually rebuild is the triggers, the schedules and the managed OAuth connections - keep the code free of platform helpers and that stays true.
Pipedream FAQ
How does Pipedream pricing actually work?
It bills compute time. Pipedream's documentation states that one credit covers 30 seconds of compute at the default 256MB of memory per workflow execution, and that raising memory scales credit usage proportionally. So the question that determines your bill is how long your workflows run, not how many steps they have. A workflow that finishes in two seconds consumes a small fraction of a credit; one that waits on a slow API for thirty seconds consumes a full one. There is a free tier with a daily allowance.
Why could you not quote the paid plan prices?
Because we could not read them off a publicly accessible pricing page when we checked in August 2026, and this site does not publish figures it has not verified at source. Paid monthly plans with larger credit pools do exist. The rule we apply everywhere is that an unverified price is worse than no price, because you would budget from it. Check pipedream.com/pricing directly and confirm the current tier before you commit to anything annual.
What breaks with Pipedream in production?
Slow external APIs are the recurring one, because they turn directly into cost - a third-party endpoint that degrades from one second to eight has just multiplied that workflow's credit consumption eightfold, silently. Second, memory increases applied to fix a failing step multiply credits proportionally, so a performance fix is a billing decision. Third, the daily-reset free allowance punishes bursty workloads that would fit comfortably inside a monthly figure. Watch the compute-time metric, not the run count.
Who should not use Pipedream?
Anyone without a developer. The pre-built triggers and actions look approachable, but almost every non-trivial workflow ends up using a code step, and that is by design - it is the product's strength. A business whose automation champion is the office manager will be happier and cheaper on a purpose-built no-code tool, even one with a less favourable meter, because the meter is not the thing that will stop them shipping.
What is Pipedream MCP?
Pipedream runs an MCP server that exposes its full integration catalogue - thousands of apps and many more individual tools - to Model Context Protocol clients like Claude, Cursor and custom agents. It is one of the most widely used MCP deployments in production. The practical value for a small business is that an AI assistant can act across your real business systems without anyone writing a bespoke integration layer first, which removes what used to be the expensive part of agent projects.
Does the Workday acquisition change anything?
It is a genuine consideration rather than a scare story. Workday announced an agreement to acquire Pipedream in November 2025, and the product has continued operating. What acquisitions commonly change over the following couple of years is pricing structure, free-tier generosity and roadmap priorities, which tend to shift toward the acquirer's enterprise customers. If you are about to make Pipedream load-bearing, ask for written pricing commitments for the contract term rather than assuming continuity.
How locked in are we?
Partially. The valuable part - your workflow logic - is real JavaScript or Python that a developer can read and reimplement anywhere, which is far better than a proprietary visual graph. What does not travel is the managed OAuth connections, the trigger infrastructure and the component registry integrations, all of which would need rebuilding. Keeping your code steps self-contained and free of platform-specific helpers wherever practical makes an eventual migration much less painful.
Pipedream or n8n for a technical team?
n8n if you want the option to self-host and keep data inside your own network, or if you want a published, predictable price. Pipedream if you want managed OAuth for thousands of apps and a compute-time meter that rewards fast workflows. n8n's per-execution pricing is simpler to forecast; Pipedream's is often cheaper in absolute terms for short workflows and worse for slow ones. For most small businesses the self-hosting option tips it toward n8n.
Can you build and maintain this for us?
Yes. Code-based automation platforms are where the gap between a working prototype and something that survives unattended is widest, because there is nobody stopping you from shipping something fragile. We scope it on a free automation audit, build it with proper error handling and alerting, and hand over the code, the account and documentation you own outright, plus a recurring plain-language report of what ran, what it saved and what needs attention.
Looking at alternatives? If you can write JavaScript or Python, Pipedream is one of the most capable automation platforms available and its MCP catalogue is a genuine asset for agent builders. Two things to weigh on lock-in: your workflow code is yours and portable in the sense that the logic is real code rather than a proprietary graph, but the platform-managed OAuth connections and triggers are not, so a migration is a real project. And with the Workday acquisition in progress, anyone signing a long contract should ask directly about pricing commitments. Autonoly targets the opposite user: someone who does not want to touch code and prefers to describe the task and schedule it. See the Autonoly review.
