# Activepieces Integrations List for 2026, by Category

By Ossian Kettunen · 2026-10-30 · Source: https://www.activepieces.com/blog/activepieces-integrations-list-for-2026-by-category

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>Activepieces' public catalog lists 772 integrations by category: AI has 126, Marketing 105, Communication 71, though trigger depth varies significantly between apps.</p><ul><li>Companies with 500-2,000 employees run 781 SaaS apps, exceeding the 772-app catalog.</li><li>Communication lists 71 integrations, 34 fewer than Marketing's 105 across categories.</li><li>Six of every 10 integrations written by volunteers, creating maintenance risks.</li></ul></aside>

What matters is whether your app's specific triggers and actions exist, not how many integrations the catalog holds. The [Activepieces](https://www.activepieces.com/pricing) integrations list is the public catalog of connectors, called pieces, at activepieces.com/integrations.

**It holds 772 integrations**, and each integration bundles the triggers and actions for one app, so the tools in your stack are likely covered.

![Grid of integration cards with triggers and actions](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/913f0fa7-922e-4f9b-af07-c39b178fcd17/activepieces-integrations-list-for-2026-by-categ-e65f9fce.webp)

The Activepieces integrations list is the catalog of pieces, the connectors that each package one app's triggers and actions, which you can browse by category to see which apps an Activepieces workflow can start from or act on.

As of 30 October 2026, these are the figures.

## The Activepieces integrations list is a catalog, not a count

### What an integration contains: triggers, actions and authentication

It's a set of triggers (events that start a flow, such as a new email arriving) and actions (steps a flow performs, such as appending a row). It also includes the authentication that lets Activepieces reach your account.

Because the core is MIT-licensed, the integrations sit in a public monorepo where you can read exactly which triggers and actions each one defines.

In the catalog, an integration with a login and one action is listed the same way as one with a dozen triggers. **Check the exact trigger or action your workflow depends on, because that's where gaps show up.**

![Activepieces connectors library page showing 457 available integrations with category filters and sample connector cards](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/d25621a0-ecc1-4d8b-8e97-bc4bebfbcdaa/kimi-k3-1-pro-for-automation-teams-in-2026-scree-63598cc5.webp)

### Where the live list lives and how to check it

When an app has no dedicated integration, Webhook and HTTP are your fallback: they receive and send web requests.

To judge how recently someone updated an integration, read its card, which lists contributors and an update time. Search for each app in your stack, open its integration, and compare its triggers and actions against your flow.

![Activepieces workflow builder showing a test flow connecting an Every Hour schedule trigger to an Ask ChatGPT action, with…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/03467db2-7c75-4863-93ee-fa5eeacac9c2/mistral-voxtral-3-speech-models-pricing-benchmar-ffafc5ff.webp)

Above the grid sits a "Showing N integrations" line. It changes as contributors add integrations, so read it live instead of trusting any figure quoted in an article, this one included.

## Integration coverage costs

Every automation platform faces the same problem: each app has its own API, authentication scheme and quirks, and someone has to write and maintain an adapter for each one. A connector is that adapter, and the cost of building them grows with every app added.

Triggers are the expensive part. An app that pushes events through webhooks lets a platform react instantly, while one that doesn't forces the platform to poll on a schedule, compare results with the last run and work out what is new.

**Many connectors ship with actions only**, because actions are far easier to build than reliable triggers.

### Polling, webhooks and the work behind a trigger

A polling trigger asks the app on a timer, often every few minutes, and keeps a record of what it saw last time so it passes on only new items. A webhook trigger registers a URL with the app and waits to be called.

![Polling trigger versus webhook trigger](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/63358d3d-100a-4920-9920-27248db82561/activepieces-integrations-list-for-2026-by-categ-fa402cbc.webp)

Webhooks are faster and cheaper, but the app has to offer them, and the connector has to re-register them when they lapse.

Authentication adds its own load. OAuth tokens expire and need refreshing, API keys need safe storage, and rate limits can throttle a busy flow. Pagination quirks and renamed fields quietly break connectors that nobody tests.

### How platforms expand their integration catalogs

Vendors have settled on a handful of approaches. Some staff a team to build and certify connectors in-house, which gives consistent quality but follows the vendor's roadmap. Some open the catalog to community contributors, which grows breadth faster and varies in depth.

Others generate connectors from an app's OpenAPI description, which is quick but covers only what the spec describes. A fourth group puts a unified API in front of a whole category such as CRMs, trading app-specific fields for a single integration.

None of these removes the long tail, so nearly every platform also ships a generic HTTP step and a code step. They let you call an API the catalog never covered, at the price of handling authentication, pagination and error cases yourself.

Connectors also drift. An app changes a field name or retires an API version, and a connector that worked last quarter starts failing.

Vendors with their own teams patch this centrally, while community catalogs depend on someone noticing, so check when an integration was last touched.

### How to evaluate an integrations catalog

Whichever approach a platform takes, the useful test is the same. List the events and actions your workflows need, then check each against the connector itself. An app count, whoever publishes it, says how many adapters exist, not how deep any one of them goes.

## Activepieces connectors grouped by category

The counts per category differ widely: AI lists 126 integrations, Marketing lists 105 and Communication lists 71, which means communication workflows start with significantly fewer pre-built options. A category with 126 integrations tells you the shelf's full, not that your app's trigger is on it.

<blockquote class="pull"><p>An app count, whoever publishes it, says how many adapters exist, not how deep any one of them goes.</p></blockquote>

### AI and agents

An AI integration that only sends a prompt and returns text is a single action, so it won't start a flow when something changes in the provider.

Here are the three counts side by side: *(chart)* 21 integrations separate AI from marketing, so the platform offers unequal support across categories. Another 34 separate marketing from communication.

At 71, communication has the fewest of the three. Chat and email integrations usually live or die on triggers, such as new message or new reply. Open the integration and confirm the trigger exists before you plan around it.

For CRM, check the field-level actions: create contact is common, but updating a custom property's where a mapping fails.

When the app is a database, a spreadsheet or a developer tool, expect it to be action-heavy: "insert row" and "create issue" before you expect a reliable "row changed" trigger.

### Built-in steps for logic and custom calls

When an integration lacks the action you need, branches, loops, code and HTTP requests are the fallback. They cost you manual setup, since you handle authentication and payload shape yourself, but they mean a missing action rarely blocks you outright.

According to the [project's GitHub repository](https://github.com/activepieces/activepieces), **community contributors wrote 6 of every 10 integrations**. That means most integrations were built by people who needed one app, so depth varies from integration to integration. Treat any integration you depend on as something to test, not assume.

![Activepieces workflow builder with HTTP request step selected and its settings panel open showing method, URL, headers, and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9e36e973-de4a-435f-8912-12e666216b2d/self-host-mistral-ai-enterprise-deployment-guide-3f7fe28d.webp)

## The strongest objection: a bigger integration list wins

Zapier and Make list far more apps than a 772-app catalog, and a company's stack grows past that catalog as the firm does.

According to [Torii's application discovery data](https://www.toriihq.com/blog/full-application-discovery), companies with **up to 100 employees run 324 SaaS apps**, revealing why no integration platform can achieve complete coverage, so you should expect to build custom code for less common applications.

![How many SaaS apps companies use, by company size](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9b3911bd-67a9-4c66-9800-2446bdefaf48/activepieces-integrations-list-for-2026-by-categ-53381792.svg "Source: Torii")

A small team already runs a stack that's a large share of a 772-app list.

At 100-500 it's 485 apps, which leaves little slack for the niche tools every department adds.

At 500-2,000 employees the figure is 781, already past 772. At 2,000-5,000 it's 1,079. At 5,000+ it's 1,174.

| Platform | Apps listed | Source page | Date checked | Open-source status |
|---|---|---|---|---|
| Activepieces | 772 | Activepieces pieces directory | 2026-10-30 | MIT-licensed Community Edition |
| Zapier | 9,000+ | Zapier app directory | 2026-10-30 | Proprietary |
| Make | 3,000+ | Make apps page | 2026-10-30 | Proprietary |

An app listed by Zapier may have only a single trigger and no write action, which is useless if your job is creating records.

When the app you need is missing, someone must build a custom connector that handles authentication, writes each trigger and action, maps the fields, and is maintained when the vendor changes its API.

So the objection stands for stacks heavy on long-tail apps. It fails only where your named apps are present with the actions you need.

## Coverage depth and extensibility across integrations

You can still get stuck on a listed app, because "supported" only means a connector exists, not that it carries the one trigger or action your workflow needs. The per-integration numbers show how uneven that is.

### Check actions and triggers, not app names

Writing to a spreadsheet gives you plenty of routes, but starting a flow from a change there leaves you few: Google Sheets has **27 actions but only 4 triggers**, according to [Activepieces](https://www.activepieces.com/pieces/hubspot).

![Actions and triggers in Activepieces pieces for popular apps](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9f74233d-9af6-439b-95a1-42f85af308ad/activepieces-integrations-list-for-2026-by-categ-dfcd74c0.svg "Source: Activepieces")

Per [Activepieces](https://www.activepieces.com/blog/activepieces-credits-pricing-and-usage-2026-guide), Slack lists 29 actions and 14 triggers, which means message events can start flows and not just receive output.

In this comparison, HubSpot, the CRM, has 45 actions and 24 triggers, the deepest of the group. Notion sits at 15 actions and 4 triggers, so a flow that has to react to a page change is working with a thin set.

![HubSpot card with many tiles beside Notion card with few](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/61b7e0a8-f246-4f44-8dea-ef420fcc1d12/activepieces-integrations-list-for-2026-by-categ-ec99d20e.webp)

Those four rows say nothing about your stack until you name the event, so their usefulness entirely depends on which event you specify.

Write down the exact trigger ("new row," "deal stage changed") and the exact action ("update a custom property"), then look for each on the integration's page.

### Fallbacks when a connector is missing

When the action you need is absent, you have three routes, in rough order of effort. Call the app's REST API with a generic HTTP step, catch its events with a webhook trigger, or write a custom integration in TypeScript.

## What Activepieces integrations require and cost

Run the Community Edition yourself, or pay for managed hosting and the controls a larger team asks for: that gap, between the MIT-licensed Community Edition and the paid plans on the pricing page, is the subscription difference.

Under the MIT license, the [Community](https://community.activepieces.com/t/scaling-pieces-with-ai-a-rolling-announcement/4327) Edition is the open-source core. You can read it, fork it and run it without a subscription, which makes it the baseline for any cost comparison.

In a closed catalogue a missing connector waits on the vendor's roadmap, but on Activepieces an AI-generated integration can be kept private to your own deployment, with no vendor release to wait for.

Roughly 60% of the integrations in the [public monorepo](https://github.com/activepieces/activepieces/tree/main/packages/pieces/community) were written by contributors outside the company, and MoneyGram, Moneypenny, Alan and FundingSocieties run Activepieces, indicating the platform has achieved both organic community adoption and real production use, so you benefit from both community-sustained development and battle-tested reliability.

![Share of Activepieces pieces written by the community](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ed059395-92a3-49a0-87ff-d85956ddca7b/activepieces-integrations-list-for-2026-by-categ-2eab53f2.svg "Source: Activepieces")

If SSO beyond the Team tier, audit logs or embedding decide your rollout, those are sales-form conversations, not self-serve checkboxes.

### Self-hosting and which connectors come along

If you self-host, you run the platform on your own infrastructure and own its upgrades, backups and uptime. The subscription you skip becomes engineering time, so count that cost against the plan price.

For this article's argument, the check that matters is narrower. Confirm that the specific triggers and actions you need are available in the build you deploy, not just in the cloud catalog.

Open the integration for each app in your stack and look for the exact trigger event and the exact action fields you would map. A connector that lists "create record" but not your custom field is a gap, wherever it runs.

### What does not exist yet

Don't assume SOC 2 certification. The programme is in progress, so if your procurement team needs a report today, ask sales what can be shared and don't write it into a vendor questionnaire as done.

Likewise, a missing trigger isn't fixed by choosing a plan. The fallback is a webhook or a custom integration you build and maintain, and that cost belongs in the same comparison as the subscription.

For plan details, use the [pricing page](https://www.activepieces.com/pricing). For self-hosted enterprise, SSO, audit logs or embedding, use the [sales form](https://www.activepieces.com/sales).

## How Activepieces handles a missing integration

When your app isn't in the catalog, you work through four options in order, from cheapest to most expensive, and **only the last one costs developer time**.

1. Search the catalog for the app by name, then open its piece and read the list of triggers and actions.
2. Test the trigger you need in a free cloud account.
3. If no integration exists, or it lacks the action you need, use the HTTP step to call the app's API directly.
4. If the HTTP step is too clumsy for the job, build a TypeScript integration and contribute it.

### Search the catalog and test a trigger

Being listed tells you the app exists, not that it has the trigger you need. Open the integration and look for the specific event: "new row in a sheet" and "new invoice paid" are different triggers, and an app can offer one without the other.

With ten actions and no triggers, an integration can only be called by something else; it can't start your flow.

Then test it. Sign up for a [free cloud account](https://cloud.activepieces.com/sign-up), add the trigger, connect a real or sandbox account, and use the test step to pull a sample record.

Check that the fields you plan to map, such as the customer email or the order ID, appear in the sample. If they are missing, the integration won't do the job as it stands, whatever the catalog says.

### Build or request a integration

If the integration is missing or thin, the HTTP step is the fastest route. You supply the endpoint, the method, the headers and the body from the app's API documentation, and the response feeds later steps like any other output.

You handle authentication and pagination yourself, so it suits a handful of calls better than a large surface area.

Anything that must start a flow needs a webhook the app can send, because the HTTP step also gives you no polling trigger.

When you need a trigger, or you'll reuse the app across many flows, build an integration in TypeScript. Integrations are open source, so you can contribute yours back and let others maintain it with you.

Plan for real developer time: authentication, each action, each trigger and its testing are all yours to write. For a one-off need, the HTTP step is almost always the better trade.

Start with the [free cloud account](https://cloud.activepieces.com/sign-up) and test the trigger before you plan anything bigger.

## Frequently asked questions

### How many integrations does Activepieces have?

Trust the live catalog, because the number changes as integrations are added and it says nothing about depth.

An integration can list dozens of actions and triggers, or one action and no trigger. Open the catalog, search for each app in your stack, and check whether the specific trigger and action you need are there.

### What the free and paid plans cover

You can self-host the MIT-licensed Community Edition for free, and the integrations are open source. Paid plans cover things like SSO beyond the Team plan, audit logs and embedding, so check the pricing page for what each tier includes before you plan a team rollout.

### Adding an integration that isn't listed

You can add an integration that isn't on the list. Integrations are written in TypeScript and the project is open source, so you can build your own for an app that is missing.

That costs engineering time, though, so first check whether the app's generic HTTP or webhook route covers your trigger and action. If it does, you may not need a custom integration at all.

### MCP and AI provider support

MCP is supported, and AI providers connect through the integrations. Support for a given provider or tool still comes down to the individual integration, so confirm that the model and the action you want are in the catalog before you build a flow around them.

### Where to test and where to ask

To test your own apps in the live catalog, [start a free cloud account](https://cloud.activepieces.com/sign-up). For plans, read the [pricing page](https://www.activepieces.com/pricing). For self-hosted enterprise, SSO beyond Team, audit logs or embedding, use the [sales form](https://www.activepieces.com/sales).

## Related reading

- [FedRAMP Authorized Vendor List for Secure Integrations](https://www.activepieces.com/blog/fedramp-authorized-vendors-list-2026-integration-guide)
- [8 Essential Marketing Automation Integrations for 2026](https://www.activepieces.com/blog/marketing-automation-integrations)
- [3rd Party Integrations: Meaning, Types and How They Work](https://www.activepieces.com/blog/third-party-integrations)

## References

- [Activepieces](https://www.activepieces.com/pieces/hubspot)
- [Torii](https://www.toriihq.com/blog/full-application-discovery)
- [Activepieces](https://github.com/activepieces/activepieces)
