July 27, 2022
5 mins

How long does it take to Integrate Bubble with a 3rd Party Product or API?

Often I am asked how long does it take to integrate Bubble to a 3rd party API? It really depends. It can be ridiculously easy or take many days of effort.  

Bubble has the capabilities that make API & Product integration quick and easy.
And 3rd party Product & API's have ways of making integration slow and complex.

Example Integration Time

To give you an idea here are some time efforts to integrate various 3rd party API's - this is from the very start to having a useful implementation running in a Bubble App.

- Jira - 30 minutes (about as easy as it gets)
- Intercom - 5-30 minutes (about as easy as it gets)
- Google SSO and Google calendar (2 hours - a lot of community information but too many API's to wade through to figure out what is what)
- Bullhorn - an Enterprise ATS - 2 weeks (classic Enterprise API, poorly documented and very small community) - I made a plugin https://bullhorn-ats.bubbleapps.io/version-test
- Google Private Cloud Storage - 1 hour (mostly spent figuring out which of the numerous Bubble plugins to use)
- Square - embedding the SDK - 5 days (technically quite difficult ) https://square-payments-plugin.bubbleapps.io/version-test
- Square API - 20 minutes (near trivial but the API calls need some orchestration)
- Intercom - 1 hour (was mostly understanding the security settings)
- Stripe - 10 minutes - seriously - it's effectively native to Bubble
- Google, Facebook social logins - minutes - Bubble native
- Linkedin SSO - https://linkedin-plugin-demo.bubbleapps.io/version-test - 2 hours - mostly to do with understanding Linkedin's API and access levels
- Wonde - an Enterprise API for School Data - 2 hours - mostly understanding the organisation hierarchy and how it doesn't paginates-
- MS Graph - 4 hours the Oauth dance and Scopes to the numerous MS API's
- Draftable - 1 day discovering the undocumented edge cases around how the API worked. Great product though.
- Sendgrid, Postmark https://postmark-template.bubbleapps.io/version-test - 30 minutes each - I made a plugin to make it easier.
- Twilio - an hour - mostly to do with account setup
- Active Campaign - 2 hours - mostly do do with setting the account up via the API
- Vimeo - a day - poorly documented API making it hard to understand the concepts - I made a plugin to make it easier https://vimeo-uploader.bubbleapps.io/version-test

Bubble Plugins

There are a lot of pre-built plugins (of varying quality) and for many things off-the-shelf Bubble plugins exist. Integrating using a plugin typically takes 5-30 minutes. You need some credentials and basic functional understanding and you are probably already up and running. Sometimes if you understand the 3rd party API or Product already integration using a plugin is under a minute. Hard to believe if you aren't a Bubbler :-) 

If it is a popular product with an API it's likely Bubble already has that plugin, or the top few in that category of product. Too many examples to list. https://bubble.io/plugins Try searching for Payment provider plugins - there are numerous Stripe, Square, Dwolla, Paypal, Razorpay, Xero, Transferwise, Opensea, Paystack ... + a 100 others to wade through.

The issue is mostly selecting and evaluating the plugin.

If there isn't already a plugin then the next step is ....

The API connector

The Bubble API connector is a beautiful piece of engineering and many plugins are based on it. Given a REST API, and some credentials you can integrate to an API in 5 minutes. How quickly that can be useful to you depends on the documentation of that API. Some API providers go to great lengths to make it easy to understand eg Stripe, Square, Google, Facebook, Xero.  

There are plenty of badly documented API provider examples. Typically you can see the API provider has a small User base, so investing in documentation for mass market distribution is not an investment they have made. Small User base in this case means under 5,000 users. Bubble has 2 Million users.

The worst cases are typically the documentation is a PDF dated 2012, and typically the model is something like "send a support email if you have a support contract with us and we will explain the API and how it works to you (maybe)". Integrating to these API providers typically takes a few days.

Sometimes you just get stuck trying to understand the API with the product names.  Who knows the difference between "Checkout Express" vs "Stripe Connect" vs "Enterprise Light" vs "Payment Buddy V1". 😃

As integrators, we just need to understand which one is the one we need - and no I really don't want to book a call with you to hear how "What used to be called 'Pay Master 2000' is now called 'Ezy Wallet v2' but the documentation isn't up to date."

Note to Product Managers - no one is really interested or cares what you call your products. Sorry.

You can sometimes quickly hit the limits of the Bubble API Connector...

- You can not see error messages when the API connector fails (only API data level errors)
- Bubble gets confused with custom types when you have created multiple custom type versions in the same app
- You can't manipulate lists in Post requests
- You can't chain requests together to orchestrate complex calls
- You can't coordinate retries with temporary errors
- You can't use (or view) the Authentication Tokens - it's under the covers inside the API Connector

Once you reach the limitations of the API Connector the next step is ....

Code a Plugin

Bubble plugins are what gives Bubble its superpowers. You can code a Plugin (surprisingly easy, it's just javascript and NodeJS). It. takes a bit of time and effort to get your head around how browser Events work, and how the Request object is overloaded and behaves weirdly at times. But there is a lot of community support for Plugin builders. The limit to writing plugins is that they run as AWS Lambda with 128M memory and a throttled execution time of around 20 seconds.

Once you reach the limitations of plugins then the next step is ....

Code your own API or Externalise the DB

When things get too intensive (long-running DB operations are a problem for Bubble) then you can easily integrate to an external data source. It's a common journey people take with Bubble. Plenty of discussion on this in the forum, Xano is a popular choice. Airtable users frequently migrate to Bubble.

Old school Enterprise SOAP API's from a PDF with no public community support can take weeks!

It's great to work with well-documented products & API's designed for embedding & self-service usage but many Enterprise products are not like this.😃

Some of the challenges you can face with Enterprise products are;
- getting current API documentation (which may not exist!)
- getting access to a Sandbox (which may not exist!)
- getting credentials to use the service (may take weeks, require calls, agreements, licenses)
- getting test accounts setup (may take days or weeks with a service request)
- actually write the code and implement the API (will likely take hours)
- dealing with the discovery of the quirks and undocumented features that are uncovered after integrating - can take weeks

So there's my answer to "how long does it take to integrate Bubble with X"

More of my plugins - my Bubble Contributor profile