# How to decide between using the API Connector or a plugin for API calls in Bubbl

- Tool: Bubble
- Difficulty: Intermediate
- Time required: 15-20 min
- Compatibility: All Bubble plans
- Last updated: March 2026

## TL;DR

Choosing between Bubble's API Connector and a pre-built plugin for external integrations is one of the most impactful decisions you will make. This tutorial provides a clear decision framework covering cost, flexibility, maintenance, and reliability — helping you pick the right approach for each integration in your Bubble app.

## Overview: Deciding Between API Connector and Plugins in Bubble

Bubble offers two primary ways to connect to external services: pre-built plugins from the marketplace, and the API Connector for direct REST API calls. Each has tradeoffs. Plugins are faster to set up but introduce dependency on a third-party developer. The API Connector gives you full control but requires more configuration. This tutorial helps non-technical founders make this decision confidently for every integration they need.

## Before you start

- A Bubble account with an app that needs an external integration
- Basic understanding of what APIs do (send and receive data between services)
- Familiarity with Bubble's Plugins tab and how to install plugins

## Step-by-step guide

### 1. Identify what you need from the integration

Before choosing an approach, write down exactly what you need: Which external service? What actions do you need (read data, write data, trigger events)? How often will it run? Does it need to work in real-time or can it be batched? For example, if you need Stripe payments, you need: create charges, handle webhooks, manage customers. If you need weather data, you only need: read current weather for a location. Simple read-only integrations lean toward API Connector. Complex integrations with UI elements (like Stripe Checkout) lean toward plugins.

**Expected result:** A clear list of what the integration must do, helping you evaluate both options objectively.

### 2. Evaluate available plugins in the marketplace

Go to the Plugins tab and click Add plugins. Search for the service you want to integrate. For each plugin you find, check these criteria: (1) Number of installs — higher is better, indicating community trust. (2) Last updated date — plugins not updated in 6+ months may not work with current Bubble. (3) Reviews and ratings — read negative reviews for specific issues. (4) Developer reputation — click the developer name to see their other plugins. (5) Pricing — one-time vs monthly subscription. (6) Documentation — does the plugin page explain setup clearly? A plugin with thousands of installs, recent updates, and good reviews is usually a safe bet.

> Pro tip: Check the Bubble forum for posts about the plugin. Search for '[plugin name] broken' or '[plugin name] issue' to find community-reported problems before you commit.

**Expected result:** You have a shortlist of candidate plugins with quality scores based on installs, updates, reviews, and pricing.

### 3. Assess the API Connector alternative

Open the external service's API documentation (usually at docs.servicename.com or developer.servicename.com). Check: (1) Does it offer a REST API with JSON responses? Bubble's API Connector only works with REST/JSON. (2) What authentication method does it use? API Connector supports API keys, OAuth2, JWT, and Basic Auth. (3) How many endpoints do you need? If you only need 1-2 calls, the API Connector is straightforward. If you need 10+, a plugin saves time. (4) Is the API well-documented with examples? Good docs make API Connector setup much easier.

**Expected result:** You understand whether the external service's API is compatible with Bubble's API Connector and how much setup it would require.

### 4. Apply the decision framework

Use this framework to choose: GO WITH A PLUGIN when the plugin is well-maintained (updated recently, 1000+ installs), the integration requires custom UI elements (payment forms, chat widgets, map embeds), OR you need complex OAuth flows that the plugin handles automatically. GO WITH API CONNECTOR when no quality plugin exists, you need only 1-3 specific API calls, the plugin is expensive and you only use a fraction of its features, OR you want full control over the request/response without third-party dependency. GO HYBRID when you use a plugin for its UI components but supplement with API Connector calls for endpoints the plugin does not cover.

> Pro tip: Plugins load their code on every page regardless of whether they are used on that page. If performance is critical, the API Connector has zero page-load overhead since it runs server-side only when called.

**Expected result:** A clear decision on whether to use a plugin, the API Connector, or a hybrid approach for your specific integration.

### 5. Set up a basic API Connector call as a fallback

If you choose the API Connector path, go to the Plugins tab, find the API Connector (pre-installed), and click Add another API. Give it a name matching the service (e.g., 'Weather API'). Add your authentication — for API key auth, click Authentication → Private key in header, and enter your key. Add a new API call: name it (e.g., 'Get Current Weather'), set the method to GET, enter the endpoint URL, and add any parameters in brackets like [city]. Click Initialize call to test it. Bubble will map the JSON response structure so you can use the data in your app. Set 'Use as' to Data if you want to display results, or Action if you want to trigger it in workflows.

**Expected result:** A working API Connector call that returns data from the external service, ready to use in your app's workflows or data sources.

## Complete code example

File: `Workflow summary`

```text
DECISION FRAMEWORK — API CONNECTOR vs PLUGIN
==============================================

STEP 1: List integration requirements
  - Service name: ___
  - Actions needed: Read / Write / Webhooks / UI components
  - Frequency: Real-time / Periodic / On-demand
  - Complexity: Simple (1-2 calls) / Medium (3-5) / Complex (6+)

STEP 2: Evaluate plugin options
  Plugin checklist:
  [ ] 1000+ installs
  [ ] Updated within last 6 months
  [ ] 3.5+ star rating
  [ ] Clear documentation
  [ ] Reasonable pricing (one-time preferred)
  [ ] No critical negative reviews
  Score: ___ / 6

STEP 3: Evaluate API Connector feasibility
  API checklist:
  [ ] REST API with JSON responses available
  [ ] Auth method supported (API key, OAuth2, JWT, Basic)
  [ ] Well-documented endpoints
  [ ] 1-3 endpoints cover your needs
  Score: ___ / 4

DECISION MATRIX:
  Plugin score 5-6 AND complexity High → USE PLUGIN
  Plugin score 0-3 OR complexity Low → USE API CONNECTOR
  Need plugin UI + extra endpoints → USE HYBRID
  Plugin expensive + only 1-2 features used → USE API CONNECTOR

API CONNECTOR SETUP:
  1. Plugins tab → API Connector → Add another API
  2. Name the API group
  3. Set authentication method + credentials
  4. Add API call: name, method, URL, parameters
  5. Click Initialize call to test
  6. Set 'Use as': Data (for display) or Action (for workflows)
  7. Use in app: Data source or Workflow action
```

## Common mistakes

- **Choosing a plugin without checking its update history** — Bubble updates its platform regularly, and plugins that are not maintained can break after platform updates with no fix available. Fix: Always check the 'Last updated' date on the plugin page. Avoid plugins that have not been updated in the last 6 months.
- **Installing multiple plugins for the same service** — Each plugin adds code to every page load regardless of use, increasing load time and potential conflicts. Fix: Pick one plugin or use the API Connector. Remove unused plugins from the Plugins tab to reduce page weight.
- **Putting API keys in non-private API Connector parameters** — Parameters without the Private checkbox are sent through the user's browser, exposing your API credentials. Fix: Always check the 'Private' checkbox for any parameter containing an API key, token, or secret.
- **Not initializing API Connector calls before using them** — Bubble cannot map the response structure until you initialize the call. Using an uninitialized call returns no data. Fix: Click 'Initialize call' for every new API call and verify the response structure before using it in your app.

## Best practices

- Start with the API Connector for simple integrations — it is always available and has zero page-load overhead
- Check the Bubble forum for community feedback on plugins before installing them
- Remove plugins you are no longer using to reduce page load times
- Mark all sensitive parameters as Private in the API Connector to keep credentials server-side
- Test API Connector calls with sample data during initialization — do not use production credentials
- Keep a document listing which integrations use plugins vs API Connector for future maintenance
- Consider the total cost of plugins over 12 months when comparing to the one-time effort of API Connector setup

## Frequently asked questions

### Is the API Connector harder to use than a plugin?

It requires more initial setup — you need to configure authentication, endpoints, and parameters manually. But for simple API calls, it takes about 10 minutes and gives you more control than most plugins.

### Do plugins slow down my Bubble app?

Yes. Every installed plugin loads its code on every page, even pages that do not use the plugin. This increases page load time. The API Connector has no page-load overhead since it runs server-side only when called.

### Can I switch from a plugin to the API Connector later?

Yes, but you will need to update every workflow and data source that references the plugin. Plan the migration carefully — map every place the plugin is used before removing it.

### What if the API I need does not have a REST endpoint?

Bubble's API Connector only supports REST APIs with JSON responses. For SOAP, GraphQL, or other protocols, you will need a plugin (if one exists) or a middleware service like Make or Zapier to translate between protocols.

### Should I use a plugin for Stripe in Bubble?

Yes — Stripe is one of the clearest plugin wins. The official Stripe plugin provides Checkout UI components and handles the complex payment flow. Use the API Connector only for Stripe endpoints the plugin does not cover.

### How do I handle it when my plugin breaks after a Bubble update?

Contact the plugin developer through the Bubble forum or their support channel. If they are unresponsive, consider migrating to the API Connector or an alternative plugin. For critical integrations, RapidDev can help architect a reliable replacement.

---

Source: https://www.rapidevelopers.com/bubble-tutorial/decide-api-connector-plugin-api-calls-bubble
© RapidDev — https://www.rapidevelopers.com/bubble-tutorial/decide-api-connector-plugin-api-calls-bubble