eBay API

Go to developer.ebay.com and sign in with your eBay account (or create a free Developer Program account). In the developer portal, navigate to 'My Account' → 'Application Access Keys.' Click 'Create a Keyset' if you don't have one, or use an existing application's keyset. eBay provides two environments: Sandbox (for testing with fake data) and Production (for real eBay data). Start with Sandbox. For each environment, eBay generates three credentials — you need two: - **App ID (Client ID)**: identifies your application - **Cert ID (Client Secret)**: used to obtain Application tokens via client credentials grant You will also need the **RuName (eBay Redirect URL name)** for the User token flow. Go to 'User Tokens' in the developer portal → 'Get a Token from eBay via Your Application' → generate a RuName and set your redirect URI to your Bubble app's page URL (e.g., `https://yourapp.bubbleapps.io/ebay-callback`). Note that the OAuth consent URL endpoint and the token exchange endpoint differ between Sandbox and Production. Sandbox uses `https://auth.sandbox.ebay.com/oauth2/authorize` and `https://api.sandbox.ebay.com/identity/v1/oauth2/token`. Production uses `https://auth.ebay.com/oauth2/authorize` and `https://api.ebay.com/identity/v1/oauth2/token`. In this guide, we use the Production endpoints; substitute Sandbox equivalents during testing.

1// eBay credentials you need:
2// App ID (Client ID): AppID-abc123def456...
3// Cert ID (Client Secret): CertID-abc123def456...
4// RuName (for User token OAuth): YourApp-YourApp-ProductN-abc123
5
6// API base URLs:
7// Browse API:      https://api.ebay.com/buy/browse/v1
8// Sell Inventory:  https://api.ebay.com/sell/inventory/v1
9// Sell Fulfillment: https://api.ebay.com/sell/fulfillment/v1
10// Token endpoint:  https://api.ebay.com/identity/v1/oauth2/token
11
12// OAuth consent URL (User token flow):
13// https://auth.ebay.com/oauth2/authorize
14//   ?client_id={AppID}
15//   &redirect_uri={RuName}
16//   &response_type=code
17//   &scope=https://api.ebay.com/oauth/api_scope/sell.inventory
18//         %20https://api.ebay.com/oauth/api_scope/sell.fulfillment

Before building API calls, set up the data structure that will hold your eBay access tokens. In Bubble's Data tab, click 'New type' and create a type called 'EbayToken' with these fields: - `access_token` (text) — the current Bearer token - `refresh_token` (text) — the long-lived refresh token (for User token flow only; 18-month TTL) - `token_expiry` (date) — when the access token expires (2 hours from issuance) - `token_type` (text) — either 'application' or 'user' - `user_id` (text) — eBay seller's user ID (for User token rows only) This design allows one row for the Application token (for Browse API) and one row per seller for User tokens (for Sell/Fulfillment APIs). Next, go to the Data tab → Privacy and add a privacy rule for 'EbayToken': set 'Everyone else' to deny all access. Only the Bubble app's Backend Workflows should read and write token records — no frontend user should ever access this data type directly. Also create a Backend Workflow called 'RefreshApplicationToken' (you'll configure it in the next step). This workflow will run on page load for any page that needs Browse API calls, check whether the stored Application token is within 5 minutes of expiry, and exchange credentials for a fresh token if needed.

1// EbayToken Data Thing fields:
2// access_token (text)
3// refresh_token (text)
4// token_expiry (date)
5// token_type (text)     -- "application" or "user"
6// user_id (text)        -- seller's eBay user ID (user tokens only)
7
8// Privacy rule for EbayToken:
9// Everyone else: No access to all fields
10// Backend Workflows: full access via server-side operations
11
12// Workflow logic for token check:
13// If EbayToken's token_expiry is before Current date/time + 5 minutes
14//   → run RefreshApplicationToken (or RefreshUserToken) Backend Workflow
15// Else
16//   → proceed with existing access_token

Application tokens use the OAuth 2.0 client credentials grant — your Bubble app exchanges its App ID and Cert ID for a token without any user involvement. This is the token used for all Browse API calls (public product search). In Bubble's Backend Workflows section (visible after enabling the Workflow API in Settings → API), create a workflow called 'FetchApplicationToken.' This workflow makes a POST call to eBay's token endpoint. In the workflow, add a 'Plugins → API Connector' action pointing to a call you're about to configure. In Plugins → API Connector, click 'Add another API' and name it 'eBay Auth.' Add a call named 'Get Application Token.' Set: - Method: POST - URL: `https://api.ebay.com/identity/v1/oauth2/token` - Header: `Authorization: Basic [base64(AppID:CertID)]` — mark Private - Header: `Content-Type: application/x-www-form-urlencoded` - Body: form-encoded with `grant_type=client_credentials&scope=https://api.ebay.com/oauth/api_scope` Click Initialize call — eBay returns a JSON response with `access_token`, `expires_in` (seconds), and `token_type`. Bubble auto-detects the response fields. Back in the FetchApplicationToken Backend Workflow, after the API call action, add a 'Create/modify Thing' action to upsert the EbayToken record: set access_token to the API call's `access_token` result, token_expiry to 'Current date/time + expires_in seconds' (use Bubble's ':plus seconds' operator), and token_type to 'application.' Now create the main eBay API Connector for Browse API calls. Click 'Add another API' and name it 'eBay API.' Set a shared header `Authorization: Bearer [dynamic_access_token]` — this token value will be fetched from the EbayToken Data Thing at workflow run time. Also add `X-EBAY-C-MARKETPLACE-ID: EBAY_US` as a shared header. Add a call for product search: GET `https://api.ebay.com/buy/browse/v1/item_summary/search` with parameters `q` (text, dynamic), `limit` (text, default '20'), and `offset` (text, default '0'). Initialize with a real product search query.

1// eBay Auth → Get Application Token
2// Method: POST
3// URL: https://api.ebay.com/identity/v1/oauth2/token
4//
5// Headers:
6// Authorization: Basic <base64(AppID:CertID)>  // mark Private
7// Content-Type: application/x-www-form-urlencoded
8//
9// Body (form-encoded):
10// grant_type=client_credentials
11// &scope=https://api.ebay.com/oauth/api_scope
12
13// Successful response:
14// {
15//   "access_token": "v^1.1#i^1#p^3#I^3#r^0#f^0#t^H4sI...",
16//   "expires_in": 7200,
17//   "token_type": "Application Access Token"
18// }
19
20// eBay API → Browse Product Search
21// Method: GET
22// URL: https://api.ebay.com/buy/browse/v1/item_summary/search
23//
24// Shared Headers:
25// Authorization: Bearer <dynamic: EbayToken's access_token>  // mark Private
26// X-EBAY-C-MARKETPLACE-ID: EBAY_US
27//
28// Parameters:
29// q: <dynamic>        -- search keyword
30// limit: 20           -- results per page
31// offset: 0           -- pagination offset

Seller API access requires a User token — an eBay seller must authorize your app via eBay's OAuth consent screen. This is a multi-step flow that requires a Backend Workflow on a Bubble paid plan. The flow works as follows: your Bubble app redirects the seller's browser to eBay's authorization URL. After the seller approves, eBay redirects back to your Bubble callback page with a one-time `code` parameter in the URL. A Backend Workflow then exchanges that code for access and refresh tokens. **Step 1 — Build the redirect URL.** On the page where sellers initiate the connection, add a 'Go to external website' action that constructs this URL: ``` https://auth.ebay.com/oauth2/authorize ?client_id={YourAppID} &redirect_uri={YourRuName} &response_type=code &scope=https://api.ebay.com/oauth/api_scope/sell.inventory https://api.ebay.com/oauth/api_scope/sell.fulfillment https://api.ebay.com/oauth/api_scope/sell.account ``` Note: scope values must be space-separated and URL-encoded (%20) in the final URL. **Step 2 — Create the callback page.** Create a Bubble page at the URL path you registered as your RuName redirect (e.g., `/ebay-callback`). On page load, read the `code` URL parameter using Bubble's 'Get data from page URL' operator. **Step 3 — Exchange code for tokens.** In the API Connector, create a 'Get User Token' call: POST to `https://api.ebay.com/identity/v1/oauth2/token` with the same Basic Auth header as the Application token call, body: `grant_type=authorization_code&code={code_from_url}&redirect_uri={RuName}`. On the callback page load, trigger a Backend Workflow that runs this API call and saves the resulting `access_token` and `refresh_token` to a new EbayToken row with token_type='user' and user_id set from eBay's response or a subsequent API call to `/sell/account/v1/privilege`.

1// Step 1: Redirect URL (build as dynamic text in Bubble's 'Go to external website' action):
2https://auth.ebay.com/oauth2/authorize
3  ?client_id=YourAppID-abc123
4  &redirect_uri=YourApp-YourApp-ProductN-abc123
5  &response_type=code
6  &scope=https%3A%2F%2Fapi.ebay.com%2Foauth%2Fapi_scope%2Fsell.inventory
7         %20https%3A%2F%2Fapi.ebay.com%2Foauth%2Fapi_scope%2Fsell.fulfillment
8
9// Step 3: eBay Auth → Get User Token
10// Method: POST
11// URL: https://api.ebay.com/identity/v1/oauth2/token
12//
13// Headers:
14// Authorization: Basic <base64(AppID:CertID)>   // mark Private
15// Content-Type: application/x-www-form-urlencoded
16//
17// Body (form-encoded):
18// grant_type=authorization_code
19// &code=<dynamic: code from URL parameter>
20// &redirect_uri=YourApp-YourApp-ProductN-abc123
21
22// Successful response:
23// {
24//   "access_token": "v^1.1#i^1#r^1#I^3...",
25//   "expires_in": 7200,
26//   "refresh_token": "v^1.1#i^1#r^1#I^3...",
27//   "refresh_token_expires_in": 47304000
28// }

Because eBay tokens expire every 2 hours, every page that makes eBay API calls needs to verify the stored token is valid before using it. In Bubble, the cleanest approach is a 'RefreshEbayToken' Backend Workflow that runs on page load and refreshes the token if needed. In the Backend Workflows section, create a workflow called 'CheckAndRefreshToken.' Add a 'Only when' condition: 'EbayToken's first item's token_expiry < Current date/time + 5 minutes.' When this condition is true, the workflow runs the token refresh. For Application tokens (Browse API): add an API call action to run the 'Get Application Token' call you built in Step 3, then a 'Make changes to Thing' action to update the existing EbayToken row with the new access_token and updated token_expiry. For User tokens (Sell/Fulfillment): add an API call to a 'Refresh User Token' connector call — POST to `https://api.ebay.com/identity/v1/oauth2/token` with body `grant_type=refresh_token&refresh_token={stored_refresh_token}&scope={same scopes}`. Update the EbayToken row with the new access_token and token_expiry. On each page that needs eBay API data, add a 'Page is loaded' trigger workflow with a single action: 'Schedule API Workflow → CheckAndRefreshToken' at 'Current date/time.' This runs server-side before any Repeating Groups load their data. In your data-display workflows and elements, reference the access_token dynamically: in the API Connector call's Authorization header dynamic value, use 'Search for EbayToken where token_type is application first item's access_token.' This ensures each call uses the current token from the database, not a stale value cached at page load.

1// Backend Workflow: CheckAndRefreshToken
2// Condition: EbayToken's first item (type='application') token_expiry < Current date/time + 5 minutes
3//
4// Action 1: API Connector → eBay Auth → Get Application Token
5// Action 2: Make changes to EbayToken (where token_type='application')
6//   access_token: result of step 1's access_token
7//   token_expiry: Current date/time + 7200 seconds (2 hours)
8
9// User token refresh call config:
10// Method: POST
11// URL: https://api.ebay.com/identity/v1/oauth2/token
12//
13// Headers:
14// Authorization: Basic <base64(AppID:CertID)>   // mark Private
15// Content-Type: application/x-www-form-urlencoded
16//
17// Body:
18// grant_type=refresh_token
19// &refresh_token=<dynamic: EbayToken (type='user') refresh_token>
20// &scope=https://api.ebay.com/oauth/api_scope/sell.inventory
21//        %20https://api.ebay.com/oauth/api_scope/sell.fulfillment
22
23// Page load workflow:
24// Trigger: Page is loaded
25// Action: Schedule API Workflow → CheckAndRefreshToken (at Current date/time)

With token management in place, build the specific eBay API calls your app needs. The most common patterns are order retrieval (Fulfillment API) and inventory management (Sell Inventory API). **Orders call:** In the eBay API Connector, add a call named 'Get Orders.' Set method GET, URL `https://api.ebay.com/sell/fulfillment/v1/order`. Add parameters: `filter` (text, dynamic) — this uses eBay's filter syntax, for example `filter=creationdate:[2025-01-01T00:00:00.000Z..]` to get orders after a date, and `limit` (text, default '50'). Initialize with real filter values. eBay returns an `orders` array; each order has nested `lineItems` (array), `fulfillmentStartInstructions` (array with shipping address), and `pricingSummary` objects. In Bubble's Initialize call response mapping, expand nested fields carefully. To display individual line items, you may need to create a 'LineItem' Data Thing and populate it from the order response using a 'Create a list of Things' action in a Backend Workflow — Bubble's Repeating Groups cannot directly iterate over nested JSON arrays without flattening them first. **Listings call:** Add a call named 'Get Inventory Items.' Set method GET, URL `https://api.ebay.com/sell/inventory/v1/inventory_item`. Add parameters `limit` (default '25') and `offset` (dynamic). Initialize — eBay returns an `inventoryItems` array with nested `product` and `availability` objects. For bulk operations (updating prices on many listings), use Bubble's 'Schedule API Workflow on a list' pattern rather than a loop inside a single workflow. Select the EbayToken (or a list of listing SKUs stored in a Data Thing) as the list, and for each item, schedule a 'UpdateListingPrice' Backend Workflow. This avoids Bubble's 30-second workflow timeout on large catalogs. RapidDev's team has built seller-management dashboards with exactly this pattern — if you need a scoping call for your specific use case, reach out at rapidevelopers.com/contact.

1// eBay API → Get Orders
2// Method: GET
3// URL: https://api.ebay.com/sell/fulfillment/v1/order
4//
5// Shared Headers (on eBay API group):
6// Authorization: Bearer <dynamic: EbayToken's access_token>  // mark Private
7// X-EBAY-C-MARKETPLACE-ID: EBAY_US
8//
9// Parameters:
10// filter: creationdate:[2025-01-01T00:00:00.000Z..]   // dynamic date filter
11// limit: 50
12// offset: 0   // for pagination
13
14// Sample response structure:
15// {
16//   "orders": [
17//     {
18//       "orderId": "12-34567-89012",
19//       "creationDate": "2026-01-15T14:32:00.000Z",
20//       "orderFulfillmentStatus": "NOT_STARTED",
21//       "buyer": { "username": "buyer123", "taxAddress": {...} },
22//       "lineItems": [
23//         { "title": "Product Name", "quantity": 2, "lineItemCost": { "value": "29.99", "currency": "USD" } }
24//       ],
25//       "pricingSummary": { "priceSubtotal": { "value": "59.98", "currency": "USD" } },
26//       "fulfillmentStartInstructions": [
27//         { "shippingStep": { "shipTo": { "fullName": "John Doe", "contactAddress": {...} } } }
28//       ]
29//     }
30//   ],
31//   "total": 47
32// }