Bubble Docs
  • Introduction
  • New? Start Here
  • What is Bubble?
  • The Glossary
  • User manual
    • Getting started
      • What is Bubble?
      • Building for...
        • Web
        • Native iOS and Android
          • Mobile app quick start guide
          • What is a native mobile app?
          • Native mobile vs. web development
          • Differences in native and web elements
          • Native mobile app terminology
      • Building your first app
        • Planning features
        • Database structure
        • Design and UX
        • eCommerce and payments
          • Shopping cart
          • Checkout page
          • One-time payments
          • Subscriptions
          • Marketplace
      • Creating and managing apps
      • The Bubble editor
        • Tabs and sections
          • Design tab
            • The element tree
            • The property editor
          • Workflow tab
          • Data tab
          • Styles tab
          • Plugins tab
          • Settings tab
            • Application settings
              • Custom headers/body
              • Visual settings
              • Social media sharing
              • Translating your app
              • Email settings
              • Collaboration
            • Custom domain and DNS
          • Logs tab
        • Tools
          • Key features
          • The search tool
          • The Issue Checker
          • The element tree
          • The element property editor
          • The debugger
          • Notes
        • Previewing your app
      • Transitioning to Bubble from...
        • JavaScript
        • HTML and CSS
        • SQL
    • Design
      • Elements
        • Web app
          • The page
          • Containers
            • Groups
            • Repeating groups
            • Table elements
            • Popups
            • Floating groups
            • Group focus
          • Visual elements
          • Input forms
            • Text and numbers
            • Dates and time
            • File uploads
            • Selection controls
        • iOS and Android app
          • The view
          • Containers
          • Visual elements
          • Input forms
          • Mobile reusable elements
        • The element hierarchy
          • The element tree
        • Reusable Elements
      • Styling
        • Color variables
        • Font variables
        • Styles
        • Custom Fonts
      • Responsive design
        • Building responsive pages
        • Legacy articles
          • The Basics (Legacy)
          • Building Responsive Pages (Legacy)
          • Migrating Legacy Pages
          • Tips When Designing (Legacy)
      • Templates
      • The Component Library
      • Importing from Figma
    • Data
      • The database
        • Data types and fields
        • Creating, saving and deleting data
        • Finding data
        • Displaying data
        • Protecting data with privacy rules
        • The database editor
        • Export/import data
          • Exporting data
          • Importing data (CSV)
        • Working with location data
        • Using Algolia
        • Database structure by app type
          • Marketplace Apps
          • Directory & Listings Apps
          • Social Network Apps
          • SaaS Apps
          • Project Management Apps
          • CRM Apps
          • Professional Services Apps
          • On-demand Apps
          • Documentation/ CMS Apps
          • Applicant Tracking System (ATS) Apps
          • Portfolio Apps
          • Gallery Apps
          • Online Store / Ecommerce Apps
          • Blog Apps
          • Messaging App
          • Dashboards
          • Building Block Apps
          • Bubble as a backend
      • Files
      • Images
      • Static data
        • App texts (translations)
        • Option sets
      • Temporary data
        • Custom states
        • URL parameters
      • User accounts
        • Authentication plugins
          • Facebook plugin
          • Fitbit plugin
          • Google plugin
          • Instagram plugin
          • LinkedIn plugin
          • Pinterest plugin
          • Slack plugin
          • Wistia plugin
          • YouTube plugin
        • Cookies set by Bubble
      • Time, dates and time zones
    • Logic
      • The frontend and backend
      • Workflows
        • Events
          • Frontend events
            • Recurring workflows
            • Custom events
          • Backend events
            • Database trigger events
        • Actions
        • API Workflows
      • Dynamic expressions
      • Conditions
      • Navigation
        • Single-page applications (SPA)
        • Multi-page applications
        • Page slugs
      • Device resources
        • Location services
        • Camera/photo library
    • Workload
      • Understanding workload
        • Activity types
        • The workload calculation
        • Client-side and server-side processing
      • Tracking workload
        • Measuring
          • Using App Metrics
        • Monitoring
          • Workload notifications
          • Infinite recursion protection
      • Optimizing workload
        • Optimization framework
        • Optimization checklist
          • Page load
          • Searches
          • Workflows and actions
          • Backend workflows
        • Agency showcases
          • Minimum Studio
          • Neam
          • Support Dept
    • Security
      • Bubble's security features
      • Planning app security
      • Client-side and server-side
      • Bubble account security
      • App security
      • Page security
      • Database security
      • API security
        • API Connector security
        • Data API security
        • Workflow API security
      • Flusk
        • Overview
        • Flusk plan features
        • Getting started with Flusk
        • Flusk security tools
          • The Issues Explorer
          • Issue details
          • Tools and settings
            • Pages rating
            • Database rating
        • Flusk FAQ
      • Cookies
      • Security checklist
    • Previewing your app
      • Previewing a web app
      • Previewing a mobile app
    • Publishing your app
      • Web app
      • Native mobile app
        • Global native mobile settings
        • iOS App Store
        • Google Play Store
        • Publishing FAQ
    • AI
      • Generate apps with AI
        • About AI app generation
      • AI page designer
      • Connect to AI agents
    • Maintenance
      • Collaborators
      • Version control
        • Best practices: Version control
        • Transitioning from the legacy version control
        • Terminology: Version control
        • Version Control (legacy)
      • Commenting
      • Database maintenance
        • Copying the database
        • Restoring database backups
        • Bulk operations
          • Bulk operation methods compared
        • Wiping change history
      • Performance
        • Hard limits
        • Capacity Usage (legacy)
        • Notes on queries
      • SEO
        • Introduction to SEO
        • SEO: App
        • SEO: Page
      • Testing and debugging
        • Introduction to testing and debugging
        • The debugger
        • The server logs
        • Supported browsers
      • API workflow scheduler
    • Integrations
      • API
        • Introduction to APIs
          • What is a RESTful API?
        • The Bubble API
          • Bubble API terminology
          • Authentication
            • How to authenticate
            • No authentication
            • As a User
            • As an admin
          • The Data API
            • Data API Privacy Rules
            • Data API endpoints
            • Data API requests
          • The Workflow API
            • Workflow API privacy rules
            • Workflow API endpoints
            • API workflows
              • Creating API workflows
              • Scheduling API workflows
              • Recursive API workflows
              • API Workflow Scheduler
              • Case: Stripe notifications
        • The API Connector
          • Authentication
          • API Connector security
          • API guides
            • OpenAI
              • Authentication
              • Calls
                • ChatGPT
                  • Chat
            • Google Translate
              • How to setup Google API keys
          • Streaming API
        • API security
        • Plugins that connect to APIs
        • API Glossary
      • Plugins
        • What Plugins Can Do
        • Installing and using Plugins
        • Authentication plugins
        • Special Plugins
      • SQL Database Connector
      • Bubble App Connector
      • WorkOS
        • WorkOS SSO
        • WorkOS API
    • Infrastructure
      • Sub-apps
      • Bubble release tiers
      • Hosting and scaling
        • How Bubble hosting works
        • Scaling with Bubble
        • CDN (Cloudflare)
        • Bubble app names
        • Domain and DNS
      • Compliance
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks and standards
    • Bubble for Enterprise
      • Hosting and infrastructure
        • Dedicated instance
          • The Dedicated editor experience
          • Technical specs
          • Main cluster dependencies
          • Customizable options
          • Migration process
            • Pre-migration
            • During migration
            • Post-migration
      • Security and compliance
        • Single sign-on (SSO)
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks
        • Bubble's security features
      • Admin and collaboration
      • Priority support
      • Billing and Payment Guideline for Dedicated Instances
  • Core Reference
    • Using the core reference
    • Bubble's Interface
      • Design tab
      • Design tab (Legacy)
      • Workflow tab
      • Data tab
      • Styles tab
      • Styles tab (Legacy)
      • Plugins tab
      • Settings tab
      • Logs tab
      • Template tab
      • Toolbar
      • Top and context menu options
      • Deployment and version control
        • Deployment & Version Control Dropdown (legacy)
      • Notes
    • Elements
      • Native mobile elements
        • View element
        • List component
      • General properties
      • General properties (Legacy)
      • Styling properties
      • Styling Properties (Legacy)
      • Responsive Properties
      • Responsive Properties (Legacy)
      • Conditional formatting
      • States
      • Page Element
        • Page Element (Legacy)
      • Visual Elements
      • Containers
      • Container Layout Types
      • Containers (Legacy)
      • Input Forms
      • Reusable Elements
      • Element Templates (legacy)
    • Workflows
    • Events
      • General events
      • Element events
      • Custom events
      • Recurring event
      • Database trigger event
    • Actions
      • Account
      • Navigation
      • Data (things)
      • Email
      • Element
      • Custom
    • On-device resources
    • Data
      • Data Sources
      • Operators and comparisons
      • Search
      • Privacy
    • Styles
    • API
      • The Bubble API
        • The Data API
          • Authentication
          • Data API endpoints
          • Data API requests
        • The Workflow API
      • The API Connector
        • Authentication
        • Adding calls
    • Bubble-made Plugins
      • AddtoAny Share Buttons
      • Airtable
      • API Connector
      • Blockspring
      • Box
      • Braintree
      • Bubble App Connector
      • Chart.js
      • Circle Music Player
      • Draggable Elements
      • Dropzone
      • Facebook
      • Fitbit
      • Full Calendar
      • Google
      • Google Analytics
      • Google Optimize
      • Google Places
      • Ionic Elements
      • iTunes
      • Slidebar Menu
      • LinkedIn
      • Localize Translation
      • Mixpanel
      • Mouse & Keyboard Interactions
      • Multiselect Dropdown
      • Progress Bar
      • Rich Text Editor
      • Rich Text Editor (Legacy)
      • Screenshotlayer
      • SelectPDF
      • Slack
      • Segment
      • Slick Slideshow
      • SQL Database Connector
      • Star Rating
      • Stripe
      • Tinder-like Element
      • Twitter
      • YouTube
      • Zapier
    • Application Settings
      • App plan
      • General
      • Domain / email
      • Languages
      • SEO / metatags
      • API
      • Collaboration
      • Sub-apps
      • Versions
  • Account & Marketplace
    • Account and billing
      • Pricing and plans
        • Plans and billing
        • Billing cycle
        • FAQ: Pricing and Workload
      • Account Management
      • Building Apps for Others
      • Selling on the Marketplace
      • Plans & Billing (legacy)
    • Official Bubble Certification
      • Hiring certified developers
    • Building Plugins
      • The Plugin Editor
      • General Settings
      • Updating to Plugin API v4
      • Adding API Connections
      • Building Elements
      • Building Actions
      • Loading Data
      • Publishing and versioning
      • Github Integration
    • Building Templates
    • Application and data ownership
    • Marketplace policies
    • Bug reports
  • Vulnerability Disclosure Policy
  • Beta features
    • About the Beta features section
    • Native mobile apps
Powered by GitBook
On this page
  • What is the Bubble API?
  • The Bubble API and Privacy Rules
  • Swagger Specification
  • What is the Swagger specification?
  • How do I create the Swagger file?
  • How do I find my app's Swagger file?
  • Additional resources

Was this helpful?

  1. User manual
  2. Integrations
  3. API

The Bubble API

This section covers the different ways in which Bubble can set up API endpoints to allow other applications to read and edit your database, as well as execute workflows.

Last updated 1 month ago

Was this helpful?

Help us improve this article

This article is part of a significant update to the Bubble manual and your feedback is critical to our efforts to continuously enhance our written documentation. We would greatly appreciate if you could take a moment to let us know your thoughts on the quality of it. Thank you for your support!

The last section covered how APIs, and in particular, work from a technical perspective. Ins this section we'll have a closer look at how APIs work in Bubble.

This is the in-depth manual article series on Bubble’s API. If you want the shorter, technical reference, check out the Bubble API Reference entry:

Reference:

Bubble is designed to make it easy to connect to both other Bubble applications and external APIs in a highly flexible, secure and compatible way. Most of the highly technical stuff like setting up your app to be able to receive incoming API requests happens automatically by the click of a few buttons and offers the same functionality and security as a more resource-demanding traditionally coded application.

Because Bubble adheres to widely used web standards your application can connect to almost any other system.

What is the Bubble API?

The Bubble API is used whenever you want to accept incoming API requests.

Incoming requests happen when an external system, such as another application, initiates a connection with your Bubble application. In that case, your app needs to be ready to accept that request and know what to do with it.

Incoming requests to Bubble can do one of two things:

  • Search for, Read, create, modify or delete data in your database: this is handled by the Data API.

  • Run a workflow in your app: this is handled by the Workflow API.

Authentication
Webhooks
The Data API
The Workflow API

The Bubble API and Privacy Rules

We’ll explore how affect both the Data API and API Workflows in each section.

This means that you can set up Privacy Rules that govern the access level of not only all API clients, but individual API clients since each of them can authenticate as an existing User.

Privacy Rules determine what kind of access a user that matches specific criteria has to each data type in your app. You can view any external system (client) that tries to access your app’s API as simply another user: this is true not only in a metaphorical sense but in a real one. Bubble treats it like a user that can be logged in or not, and in certain scenarios you can even save data to it just like any other user profile.

Both the Data API and API Workflows respect your app’s Privacy Rules. This is why setting them up correctly is an essential part of constructing your API.

Swagger Specification

What is the Swagger specification?

Whenever you activate the Bubble API, it means that you want external systems to reach your application with different kind of queries. Swagger is essentially a way for your API to automatically describe itself so that other systems can understand how it's structured and what queries are available.

In essence, if your API is a restaurant, then the Swagger file is the menu.

For example, to successfully connect to your app, an external app or its developer may have "questions" like:

  • How to authenticate with your app

  • What kind of calls are available?

  • What kind of parameters are there?

  • What does the response look like?

The Swagger specification speaks a language that answers questions like this in a way that both humans and computers can understand. Bubble uses the JSON format to generate a Swagger file.

How do I create the Swagger file?

The Swagger file is generated automatically by Bubble and is dynamic in the way that it will update according to your app's settings. The Swagger file is disabled by default when the Bubble API is enabled, but you can choose to enable it under Settings - API.

How do I find my app's Swagger file?

An URL is automatically generated whenever the file is available:

https://appname.bubbleapps.io/api/1.1/meta/swagger.json or if you are connected to a domain: https://yourdomain.com/api/1.1/meta/swagger.json

Additional resources

Frequently asked questions about Swagger

Isn't it risky to expose all that information about my API?

To answer that question, it's first important to emphasize that hiding information about your apps's API does not mean it's secure: obfuscation is not security. So while the Swagger file will expose your endpoints, a determined hacker would be able to reconstruct them anyway. Security is done using authorization and Privacy Rules, not by trying to hide information about the API.

Can I make changes to the Swagger API documentation?

Yes and no: you can't make direct edits to the file, but the file will instantly reflect any relevant changes that you make to your app's settings and structure. You don't need to keep track of these changes yourself.

Are there separate files for the development and live version of my app?

Yes, there are separate URLs and files for the two different versions. Remember to point the external application to the correct file. Also, keep in mind that changes you make in your app's development version are not reflected in the live Swagger file until the app is deployed.

What does the Swagger file look like?

The Swagger file is dynamic in the way that it will look different based on how your application is set up. The example below can give you an idea of the basic structure. In this example, both the Data API and the Workflow API are activated:

{
    "swagger": "2.0",
    "info": {
        "title": "my-bubble-application",
        "version": "1.0.0",
        "contact": {
            "email": "my-bubble-application-no-reply@bubbleapps.io"
        }
    },
    "host": "my-bubble-application.bubbleapps.io",
    "basePath": "/version-test/api/1.1",
    "schemes": [
        "https"
    ],
    "consumes": [
        "application/json"
    ],
    "paths": {
        "/obj/thing/{UniqueID}": {
            "get": {
                "description": "Retrieve a thing of type thing by unique ID",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "UniqueID",
                        "in": "path",
                        "description": "Unique ID of the thing to retrieve",
                        "type": "string",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Retrieved thing",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "response": {
                                    "$ref": "#/definitions/thing"
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            },
            "patch": {
                "description": "Modifies a thing of type thing by unique ID",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "UniqueID",
                        "in": "path",
                        "description": "Unique ID of the thing to modify",
                        "type": "string",
                        "required": true
                    },
                    {
                        "name": "thing request body",
                        "in": "body",
                        "description": "Body of the PATCH request",
                        "schema": {
                            "$ref": "#/definitions/thingBody"
                        }
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Modified thing"
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            },
            "put": {
                "description": "Replaces a thing of type thing by unique ID",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "UniqueID",
                        "in": "path",
                        "description": "Unique ID of the thing to replace",
                        "type": "string",
                        "required": true
                    },
                    {
                        "name": "thing request body",
                        "in": "body",
                        "description": "Body of the PUT request",
                        "schema": {
                            "$ref": "#/definitions/thingBody"
                        }
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Replaced thing"
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            },
            "delete": {
                "description": "Deletes a thing of type thing by unique ID",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "UniqueID",
                        "in": "path",
                        "description": "Unique ID of the thing to delete",
                        "type": "string",
                        "required": true
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Replaced thing"
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/obj/thing": {
            "get": {
                "description": "Retrieve a list of things of type thing with some optional search constraints. Retrieves 100 items at most at once.",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "limit",
                        "in": "query",
                        "description": "Number of items to fetch (maximum is 100)",
                        "type": "integer",
                        "format": "int32",
                        "default": 50
                    },
                    {
                        "name": "cursor",
                        "in": "query",
                        "description": "Position to start from in the list",
                        "type": "integer",
                        "format": "int32",
                        "default": 0
                    },
                    {
                        "name": "sort_field",
                        "in": "query",
                        "description": "Field to sort the list on",
                        "type": "string"
                    },
                    {
                        "name": "descending",
                        "in": "query",
                        "description": "Sorting type: descending or ascending",
                        "type": "boolean"
                    },
                    {
                        "name": "constraints",
                        "in": "query",
                        "description": "Search constraints, stringified array as described [here](https://manual.bubble.io/core-resources/api/data-api#search-constraints)",
                        "type": "string"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Retrieved list of things",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "response": {
                                    "type": "object",
                                    "properties": {
                                        "results": {
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/definitions/thing"
                                            }
                                        },
                                        "cursor": {
                                            "type": "number",
                                            "format": "float",
                                            "description": "Rank of the first item in the list"
                                        },
                                        "count": {
                                            "type": "number",
                                            "format": "float",
                                            "description": "Number of items in the current response. It is the minimum between the actual length of the list and the sent limit (or 100 if you did not specify a limit)."
                                        },
                                        "remaining": {
                                            "type": "number",
                                            "format": "float",
                                            "description": "Number of remaining items after the current response. Useful to fetch more items."
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            },
            "post": {
                "description": "Create a new thing of type thing",
                "tags": [
                    "Data"
                ],
                "parameters": [
                    {
                        "name": "thing request body",
                        "in": "body",
                        "description": "Body of the POST request",
                        "schema": {
                            "$ref": "#/definitions/thingBody"
                        }
                    }
                ],
                "responses": {
                    "201": {
                        "description": "Created one thing of type thing",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Success status of the operation"
                                },
                                "id": {
                                    "type": "string",
                                    "description": "Unique id of the newly created object"
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Database retrieval failure",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "status": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "401": {
                        "description": "Permission denied",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "404": {
                        "description": "Not found",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Wrong method",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "429": {
                        "description": "Too many requests",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "500": {
                        "description": "Internal bug. Please file a bug report at bubble.io/support/report with the request that triggers this bug",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "code": {
                                    "type": "string",
                                    "description": "Error code"
                                },
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    },
                    "503": {
                        "description": "Service Unavailable",
                        "schema": {
                            "type": "object",
                            "properties": {
                                "message": {
                                    "type": "string",
                                    "description": "Error message for the operation"
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "thing": {
            "type": "object",
            "properties": {
                "Score": {
                    "type": "number",
                    "format": "float",
                    "description": "'Score' field of the current Thing"
                },
                "Created Date": {
                    "type": "string",
                    "format": "date-time",
                    "description": "'Created Date' field of the current Thing"
                },
                "Modified Date": {
                    "type": "string",
                    "format": "date-time",
                    "description": "'Modified Date' field of the current Thing"
                },
                "Created By": {
                    "type": "string",
                    "description": "'Created By' field of the current Thing ('user' represented by a unique ID)"
                },
                "_id": {
                    "type": "string",
                    "description": "'unique ID' field of the current Thing"
                },
                "Slug": {
                    "type": "string",
                    "description": "'Slug' field of the current Thing"
                }
            }
        },
        "thingBody": {
            "type": "object",
            "properties": {
                "Score": {
                    "type": "number",
                    "format": "float",
                    "description": "'Score' field of the current Thing"
                }
            }
        }
    },
    "tags": [
        {
            "name": "Workflow",
            "description": "Use this to trigger a workflow"
        },
        {
            "name": "Data",
            "description": "Use this to fetch, modify and delete data"
        }
    ],
    "securityDefinitions": {
        "api_token": {
            "type": "apiKey",
            "name": "api_token",
            "in": "query"
        }
    },
    "security": [
        {
            "api_token": []
        }
    ]
}

Whenever a attempts to connect your app's , you can require them to authenticate themselves. Authentication is the process of identifying who a client is in order to determine what they have access to your your application. This article explains the three different ways a client can authenticate. Article:

Calls that are made to your app as a response to a specific event (such as a successful or failed payment) are often called webhooks. Article section: (with examples)

The Data API can give external applications access to your app's database to read, create, edit and delete records. This article explains how to set up the Data API and how to send requests to your app. Article: Reference:

The Workflow API lets you set up API workflows that can be triggered from outside of your own application without visiting any page. This article explains how to activate the Workflow API, how to create API workflows and finally how to access those workflows from an external system. Article: Reference:

You can read more about the Swagger Specification standard .

You can read more about the Swagger Specification standard .

Authentication
Webhooks
The Data API
The Data API
The Workflow API
The Workflow API
here
here
Give feedback on this article
The Bubble API
The Bubble API handles incoming requests – calls that are made from an external application to your Bubble app.
Privacy Rules serve as a secure filter to stop unauthorized access to your app's database.