# Kentico

- Tool: Bubble
- Difficulty: Advanced
- Time required: 8–12 hours
- Last updated: July 2026

## TL;DR

Kentico Xperience (XbyK) connects to Bubble via the API Connector with a Bearer API key in a Private Authorization header — but the Management API base path (/api/v1) is custom per installation and must be confirmed with your Kentico developer team before starting. Content items are fetched via GET /api/v1/content-items with a 'value' Data path; workflow transitions use POST /…/workflow/next-step. The PATCH update gotcha: every update requires an If-Match header with the item's last_modified value, or Getty returns 409 Conflict on every attempt.

## Kentico + Bubble: an enterprise CMS editorial layer for non-technical teams

Kentico Xperience is not a tool for founders starting a publication. It is an enterprise .NET Digital Experience Platform used by organizations with 50+ person teams, complex multi-market content workflows, and DX budgets in the five-to-six-figure range per year. The Bubble integration use-case is narrow but valuable: building a simplified editorial interface that lets non-technical content reviewers, translators, and approvers interact with Kentico content — without giving everyone full access to Kentico's complex administration interface.

A typical scenario: a global brand has editorial coordinators in five regional offices who need to advance content items from 'In Review' to 'Ready for Translation' workflow steps. The full Kentico admin is overwhelming for these users, so the Bubble app surfaces only the relevant content queue, workflow state, and a single 'Advance to Next Step' button. The complexity lives in Kentico; the Bubble app is the simplified front-end.

The first thing to understand about this integration: the Management API base path (`/api/v1`) is configured in the Kentico application's ASP.NET routing setup and can be changed per installation. It may not be `/api/v1` — it could be `/kentico/api/v1`, `/content/api/v1`, or something else entirely. Do not guess. The Bubble API Connector will return 404 errors for any incorrect path, and these 404s look identical to auth errors in Bubble's debugger. Confirm the exact registered base path with your Kentico developer before touching the API Connector.

Authentication uses an API key set in the Kentico application's `appsettings.json`. This key goes in an `Authorization: Bearer` header marked Private in Bubble. The Delivery API may use a separate Delivery API key — confirm with your developer team which keys are available and what each one authorizes.

The most technically demanding Bubble-specific challenge in this integration: PATCH updates for content items require an `If-Match` header containing the current item's `last_modified` value in ISO 8601 format. Kentico uses optimistic locking — if you send a PATCH without this header (or with a stale timestamp from a previous fetch), Kentico returns 409 Conflict on every attempt. The correct pattern in Bubble: fetch the content item first in a workflow action (GET /content-items/{id}), read its `last_modified` value, then send the PATCH in the next action with `If-Match` bound to that fetched value.

A legal and practical reminder: Kentico Xperience requires an enterprise license (~$36,000+/yr). This guide assumes your organization already has a Kentico installation and license. Do not start a new CMS project on Kentico for a Bubble integration — for new projects, WordPress, Ghost, or another headless CMS is far more cost-effective.

## Before you start

- An existing Kentico Xperience (XbyK) installation with a valid enterprise license (~$36,000+/yr) — this guide does NOT cover starting a new Kentico project
- The Kentico Management API base URL confirmed by your Kentico developer team (e.g., https://yoursite.com/api/v1 — do NOT guess this path)
- A Kentico Management API key provided by your developer team (configured in the .NET application's appsettings.json)
- The Delivery API base URL and key if you plan to use the Delivery API for published content reads (confirm separately from the Management API credentials)
- The API Connector plugin installed in your Bubble app (Plugins tab → Add plugins → search 'API Connector' by Bubble)
- A list of the content type codenames you will be working with (e.g., 'article', 'landing_page') — obtainable from Kentico admin → Content types
- A Bubble paid plan if you need Backend Workflows for bulk operations or scheduled tasks

## Step-by-step guide

### 1. Confirm your Kentico API base URL and credentials with the developer team

Before touching Bubble's API Connector, gather three pieces of information from your Kentico developer:

1. **Management API base URL**: The full URL including the route prefix, for example `https://yoursite.com/api/v1`. This is set in the Kentico application's `appsettings.json` under `CMSManagementApi:Url` or similar, and it can be any path. Using the wrong path causes 404 errors in Bubble that look identical to authentication failures.

2. **Management API key**: A string token configured in the .NET application. Your developer adds it to `appsettings.json` under the Management API configuration section and can generate one for your Bubble integration purpose.

3. **Delivery API details** (if applicable): A separate base URL (often the same domain with `/delivery/v2`) and a separate API key. Confirm whether your installation uses the Delivery API for published content and whether a separate key is required.

**Content type codenames**: also ask your developer for the list of content type codenames you will be working with. Kentico stores content by type, and the API filters by `contentTypeCodename`. Examples: `article`, `product_page`, `landing_page`. These are lowercase strings with underscores — not display names.

**Test outside Bubble first**: Use a REST API client (the browser's fetch or a tool like Postman) to verify your credentials work before opening Bubble:

```
GET https://yoursite.com/api/v1/content-items?limit=3
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json
```

If this returns JSON with a `value` array, your credentials and base URL are correct. If you see 404, the path is wrong. If you see 401, the API key is wrong or not yet configured.

```
// Test call to verify Kentico Management API access
// Run this in your browser console or a REST client before configuring Bubble
fetch('https://yoursite.com/api/v1/content-items?limit=3', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_KENTICO_API_KEY',
    'Content-Type': 'application/json'
  }
})
.then(res => res.json())
.then(data => console.log('Content items:', data.value))
.catch(err => console.error('Error:', err));
```

**Expected result:** You have confirmed the Management API base URL, the API key, and at least one content type codename. A direct test call returns a JSON response with a 'value' array of content items. You are ready to configure the Bubble API Connector.

### 2. Configure the Bubble API Connector for the Kentico Management API

In your Bubble editor, go to the **Plugins tab** → **Add plugins** → search **API Connector** → install the plugin by Bubble (free).

Open the API Connector panel. Click **Add another API** and name it `Kentico Management API`.

Set **Authentication** to **No authentication** (you handle auth via a custom header).

Under **Shared headers**, add:
- **Name**: `Authorization`
- **Value**: `Bearer YOUR_KENTICO_MANAGEMENT_API_KEY`
- **Tick the Private checkbox** — this keeps the API key off browser network requests

Add a second shared header:
- **Name**: `Content-Type`
- **Value**: `application/json`
- Leave Private unchecked

```json
{
  "api_name": "Kentico Management API",
  "authentication": "none",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json"
  }
}
```

Now add the primary content items call:
- **Name**: `Get Content Items`
- **Use as**: **Data**
- **Method**: GET
- **URL**: `https://yoursite.com/api/v1/content-items` (replace with your actual base URL)

Add URL parameters:
- `filter` = `contentTypeCodename[eq]:article` (replace 'article' with your type codename; this is the filter syntax Kentico's Management API uses)
- `skip` = `0` (offset for pagination — make this dynamic)
- `limit` = `20` (page size)
- `orderby` = `system.lastModified[desc]`

Click **Initialize call**. Kentico returns a response like:
```json
{
  "@odata.context": "...",
  "@odata.count": 48,
  "value": [
    {
      "system": {
        "id": "...",
        "name": "my-article",
        "codename": "my_article",
        "type": "article",
        "collection": "default",
        "last_modified": "2024-03-15T09:30:00Z",
        "language": "en",
        "workflow": "default",
        "workflow_step": "in_review"
      },
      "elements": { "title": {...}, "body": {...} }
    }
  ]
}
```

Set the **Data path** to `value` so the Repeating Group binds to individual content items.

```
{
  "method": "GET",
  "url": "https://yoursite.com/api/v1/content-items",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json"
  },
  "call_params": {
    "filter": "contentTypeCodename[eq]:article",
    "skip": "<dynamic:offset>",
    "limit": "20",
    "orderby": "system.lastModified[desc]"
  }
}
```

**Expected result:** The Initialize call succeeds. Bubble detects the 'value' array and its nested 'system' object fields including id, name, codename, type, last_modified, workflow_step, and language. Data path is set to 'value'. The Get Content Items call is saved.

### 3. Add the language variants call for workflow state display

To display the workflow state of each content item (and to build the color-coding in the editorial queue), you need to fetch language variants for each item.

Add a second call to the Kentico Management API group:
- **Name**: `Get Item Variants`
- **Use as**: **Data**
- **Method**: GET
- **URL**: `https://yoursite.com/api/v1/content-items/{item_id}/variants` (with `{item_id}` as a dynamic URL segment bound to the selected content item's ID)

```json
{
  "method": "GET",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>/variants",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>"
  }
}
```

Click **Initialize call** (use a real content item ID from your Kentico installation — find one in the results from Step 2's Get Content Items call).

Kentico returns a list of variant objects, each containing:
- `item.id` — the content item ID
- `language.codename` — the language code (e.g., 'en', 'de', 'fr')
- `workflow_step.codename` — the current workflow step identifier (e.g., 'draft', 'in_review', 'approved', 'published')
- `last_modified` — ISO 8601 timestamp (critical for PATCH updates in Step 5)

Set Data path to leave blank (the response is an array directly, not wrapped in a 'value' key — confirm this with your Kentico version; some XbyK configurations wrap in 'value', others return a direct array).

**Binding workflow step color in the Repeating Group:**

In the content items Repeating Group, add a colored indicator element (a shape or group). Add a **Conditional** on this element:
- When `Current cell's system's workflow_step = 'in_review'` → Background color: Orange
- When `Current cell's system's workflow_step = 'approved'` → Background color: Blue
- When `Current cell's system's workflow_step = 'draft'` → Background color: Grey
- When `Current cell's system's workflow_step = 'published'` → Background color: Green

```
{
  "method": "GET",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>/variants",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>"
  }
}
```

**Expected result:** The Get Item Variants call initializes and detects variant fields including language.codename, workflow_step.codename, and last_modified. The Repeating Group shows workflow step color indicators based on the current workflow_step.codename value.

### 4. Build the workflow transition Action call

The core editorial action in this Bubble app is advancing content through Kentico's workflow. The API call for this is:

`POST /api/v1/content-items/{item_id}/variants/{language_codename}/workflow/next-step`

With an empty JSON body `{}`.

In the Kentico Management API group, click **Add a call**:
- **Name**: `Advance Workflow Step`
- **Use as**: **Action** (this call modifies data, not returns data for display)
- **Method**: **POST**
- **URL**: `https://yoursite.com/api/v1/content-items/<dynamic:item_id>/variants/<dynamic:language_codename>/workflow/next-step`
- **Body type**: JSON
- **Body**: `{}` (empty JSON object — Kentico requires a valid JSON body even though no fields are needed)

```json
{
  "method": "POST",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>/variants/<dynamic:language_codename>/workflow/next-step",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json"
  },
  "body": {}
}
```

Click **Initialize call** (use a real item ID and 'en' as the language codename — ensure the item is in a non-final workflow state before testing).

**Building the Advance button workflow in Bubble:**

1. Add a **Button** element inside the content items Repeating Group with label 'Advance to Next Step'
2. On click, add a **Show Alert** action first (important!) — display a dialog: 'Advance "[current item title]" to the next workflow step? This cannot be undone automatically.' with OK/Cancel options
3. Add a condition: 'Only when the user clicks OK'
4. After the confirm, add the **Advance Workflow Step** API action, passing:
   - `item_id` = `Current cell's system's id`
   - `language_codename` = `Current cell's system's language` (or a fixed 'en' for single-language installations)
5. After success, add a **Refresh data** action to reload the Repeating Group

RapidDev's team has built Kentico editorial tooling on Bubble for enterprise clients — for complex multi-workflow, multi-language setups, reach out at rapidevelopers.com/contact for a free scoping call.

```
{
  "method": "POST",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>/variants/<dynamic:language_codename>/workflow/next-step",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json"
  },
  "body": {}
}
```

**Expected result:** The Advance Workflow Step call is configured as an Action. The Repeating Group button triggers the call with a confirmation dialog first. After a successful transition, the Repeating Group refreshes to show the updated workflow step.

### 5. Implement the If-Match header for PATCH updates

If your Bubble editorial tool needs to update content item metadata (title, author, tags, custom elements), the Management API's PATCH endpoint requires an `If-Match` header containing the item's current `last_modified` value. Missing or wrong `If-Match` causes 409 Conflict on every attempt.

**Add the PATCH call:**
- **Name**: `Update Content Item`
- **Use as**: **Action**
- **Method**: **PATCH**
- **URL**: `https://yoursite.com/api/v1/content-items/<dynamic:item_id>`
- **Headers** (in addition to shared headers):
  - `If-Match` = `<dynamic:last_modified_iso8601>` — this must be a dynamic header, not a shared header

In Bubble's API Connector, dynamic headers (headers whose value changes per call) are added as **call-level parameters** with the header parameter type, not as shared headers. Add `If-Match` as a call-level header parameter so it can be bound to a dynamic value.

```json
{
  "method": "PATCH",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>",
  "headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json",
    "If-Match": "<dynamic:item_last_modified>"
  },
  "body": {
    "elements": {
      "title": { "value": "<dynamic:new_title>" }
    }
  }
}
```

**The correct PATCH workflow sequence in Bubble:**

1. User edits a field in the Bubble form and clicks 'Save'
2. Workflow Step A: Call **Get Content Items** with `filter=id[eq]:{item_id}` to fetch the current item (re-fetching ensures you have the latest `last_modified` value)
3. Workflow Step B: Call **Update Content Item** PATCH with:
   - `item_id` = the item's id
   - `item_last_modified` = result of Step A's `last_modified` value
   - `new_title` = the user's input value
4. On 409 Conflict error, show a notification: 'This item was modified by someone else. Refreshing data...'

This two-step fetch-then-patch pattern adds one extra API call per update but prevents the 409 error reliably.

```
{
  "method": "PATCH",
  "url": "https://yoursite.com/api/v1/content-items/<dynamic:item_id>",
  "headers": {
    "Authorization": "Bearer <private: YOUR_KENTICO_API_KEY>",
    "Content-Type": "application/json",
    "If-Match": "<dynamic:last_modified_value_from_fresh_fetch>"
  },
  "body": {
    "elements": {
      "title": {
        "value": "<dynamic:new_title_value>"
      }
    }
  }
}
```

**Expected result:** The Update Content Item PATCH call is configured with a dynamic If-Match header. The Bubble save workflow first fetches the fresh item (for last_modified), then sends the PATCH. No more 409 Conflict errors when two users do not edit the same item simultaneously.

### 6. Add the Delivery API group and build the content queue display

For fast, CDN-backed reads of published content, add a second API Connector group for Kentico's Delivery API.

Click **Add another API** and name it `Kentico Delivery API`.

Under **Shared headers**, add:
- `Authorization`: `Bearer YOUR_DELIVERY_API_KEY` (mark Private — may be the same key as Management or a separate one, confirm with your developer)

```json
{
  "api_name": "Kentico Delivery API",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_DELIVERY_API_KEY>"
  }
}
```

Add a call:
- **Name**: `Get Published Items`
- **Method**: GET
- **URL**: `https://yoursite.com/delivery/v2/items` (confirm this path with your developer — Delivery API paths vary)
- Parameters: `system.type=article`, `limit=20`, `skip=<dynamic>`
- **Data path**: `items` (Delivery API typically wraps results in 'items', not 'value' — confirm per your XbyK version)

**Building the content queue Repeating Group:**

Create a Bubble page called `kentico-queue`. Add:
- A **Dropdown** for content type filter (static choices from your known codenames)
- A **Dropdown** for workflow step filter (ask your developer for codenames)
- A **Repeating Group** bound to `Kentico Management API - Get Content Items` with filter parameters bound to the Dropdowns
- Inside each cell: content type badge, title, language, workflow step (color-coded per Step 3), last_modified date, and the Advance button from Step 4

**Privacy and access control:**
- Restrict the `kentico-queue` page to logged-in users with an 'Editor' or 'Admin' role in Bubble
- In Bubble's **Data tab → Privacy**, restrict any Bubble data type storing Kentico content metadata to authorized roles
- Consider not storing Kentico content in Bubble's database at all — fetch live from the API on each page load to ensure editorial teams always see current workflow states

```
{
  "api_name": "Kentico Delivery API",
  "shared_headers": {
    "Authorization": "Bearer <private: YOUR_DELIVERY_API_KEY>"
  },
  "get_published_items": {
    "method": "GET",
    "url": "https://yoursite.com/delivery/v2/items",
    "params": {
      "system.type": "<dynamic:content_type_codename>",
      "limit": "20",
      "skip": "<dynamic:offset>"
    }
  }
}
```

**Expected result:** Both the Management API and Delivery API groups are configured. The kentico-queue page shows a content Repeating Group with workflow step color-coding. The Advance button works with a confirmation dialog. The page is restricted to authorized Bubble users. The PATCH update flow uses the fetch-then-patch pattern for correct If-Match headers.

## Best practices

- Confirm the Management API base path with your Kentico developer before starting any Bubble configuration. Using the wrong path causes 404 errors that are indistinguishable from other errors in Bubble's debugger — this single step prevents the most time-consuming debugging scenario in this integration.
- Mark the API key as Private in the Authorization shared header. Even though it is an internal tool, the Kentico Management API key grants write access to content items and workflow transitions — a leak means unauthorized content modifications in your enterprise CMS.
- Always use the fetch-then-patch pattern for PATCH updates. Never attempt a PATCH without first reading the current item to get its fresh last_modified value. Cache the last_modified value only for the duration of a single edit session — always re-fetch if the user leaves and returns to an item.
- Set Bubble privacy rules on the kentico-queue page and any related data types. Restrict page access to authenticated users with editor or admin roles. Even an internal tool should not be accessible to all Bubble users without authentication.
- Use the Delivery API for listing published content queues (faster, optimized for reads), and the Management API for workflow transitions and draft access. Do not use the Management API for high-frequency read-only listing — it is not optimized for delivery performance.
- Add a Confirm Alert before every workflow transition action. Workflow transitions may be one-way in your Kentico configuration — advancing content to 'Published' may trigger downstream processes (emails, CDN invalidation, translation dispatch) that cannot be reversed from the Bubble UI.
- Avoid storing Kentico content items in Bubble's database. Fetch live from the API on each page load to ensure editors always see current workflow states. Stale cached content in Bubble's database could lead an editor to believe an item is in 'In Review' when it has already been published.
- Remind your stakeholders early that this integration requires an existing Kentico Xperience enterprise license (~$36,000+/yr). Do not present the Bubble integration as a cost-saving replacement for Kentico — it is a complementary simplified front-end for non-technical team members, not a license cost reduction.

## Use cases

### Editorial content review queue for non-technical approvers

A global media company builds a Bubble app for regional editorial coordinators who review content before publication. The Bubble Repeating Group fetches Kentico content items in 'In Review' workflow state using the Management API, color-coded by workflow step. Coordinators read the title, content type, and responsible author, then click 'Advance to Next Step' to fire the workflow transition API call. The Bubble app shows only the information and actions relevant to the reviewer — no Kentico admin complexity.

Prompt example:

```
Build a Bubble content review dashboard that uses Kentico's Management API to list content items in 'in_review' workflow state for a specific content type (e.g., 'article'). Show title, language, workflow step name, and last modified date. Add an 'Advance' button on each row that sends POST /content-items/{id}/variants/{language}/workflow/next-step. Include a confirmation dialog before firing the transition.
```

### Translation status tracker across language variants

A multinational brand manages content in 8 languages in Kentico. A Bubble translation status dashboard fetches each content item's language variants and their workflow step codenames via the Management API. Items are grouped by translation status — 'Ready for Translation', 'In Translation', 'Translated', 'Published'. Translation project managers see which items are blocked, which are in progress, and which are ready for final review, all without needing Kentico admin access.

Prompt example:

```
Create a Bubble translation tracker that queries Kentico's Management API for content items. For each item, fetch GET /content-items/{id}/variants and display each language variant's workflow_step.codename. Group the Repeating Group by workflow step. Color-code: 'draft' = grey, 'in_review' = yellow, 'translated' = blue, 'published' = green.
```

### Bulk workflow transition panel for content operations teams

A content operations team needs to advance 50+ content items from 'Approved' to 'Scheduled' status in Kentico before a campaign launch. The Bubble app lists all items in 'Approved' state with checkboxes. Selecting multiple items and clicking 'Advance All Selected' triggers a Backend Workflow that iterates through the checked items and fires the workflow transition call for each one. A progress counter updates in real-time as the batch completes.

Prompt example:

```
Build a Bubble bulk workflow tool for Kentico. Show a list of content items in a specific workflow state with checkboxes. Include a 'Select All' toggle and an 'Advance Selected to Next Step' button that iterates through selected items and fires the POST /workflow/next-step endpoint for each, with a progress indicator showing X/Y items processed.
```

## Troubleshooting

### All API calls return 404 Not Found even though the API key seems correct

Cause: The Management API base path configured in the API Connector does not match the actual route registered in the Kentico application's ASP.NET configuration. This is the most common issue in this integration and the one that wastes the most debugging time.

Solution: Contact your Kentico developer team and ask for the exact Management API route from the application's routing configuration. Do not guess common paths like /api/v1 — they may be different. Test the confirmed path with a direct browser or REST client call before returning to Bubble. Common Kentico paths include /api/v1, /management-api/v1, and /kentico/api/v1 — but the correct one must come from the actual deployment.

### PATCH update returns 409 Conflict on every attempt

Cause: The If-Match header is missing from the PATCH request, contains a stale last_modified value from a previous fetch, or the last_modified string was reformatted before passing it (Kentico requires the exact string from the GET response, unmodified).

Solution: Implement the two-step fetch-then-patch pattern: always call GET /content-items/{id} immediately before the PATCH to get the current last_modified value. Pass the raw last_modified string — without reformatting or trimming — as the If-Match header value in the PATCH call. If another user modified the item between your fetch and patch, you will still get 409 — show the user a 'Refresh and retry' notification in this case.

### Bubble shows 'There was an issue setting up your call' on Initialize

Cause: The Initialize call returned an error instead of a valid Kentico JSON response. Possible causes: incorrect API key, wrong base URL path, the Kentico server is not reachable from Bubble's servers, or the requested content type has no items (empty response).

Solution: Test the API call outside Bubble first using a browser fetch or REST client with the exact URL and Authorization header. Confirm the call returns a JSON response with a 'value' array containing at least one item. Ensure the content type filter codename is correct (codenames are exact strings, case-sensitive) and that at least one item of that type exists in Kentico.

### Workflow transition (POST /workflow/next-step) returns 400 Bad Request

Cause: The content item is already at the final workflow step (no next step exists), the language codename is incorrect, or the item's current workflow state does not allow advancement to the next step (e.g., requires a required field to be filled).

Solution: Check the item's current workflow step in Kentico Admin and confirm there is a configured 'next step' from the current state. Verify the language codename matches exactly (e.g., 'en-US' vs 'en' — confirm the format your Kentico instance uses). If Kentico requires specific field validation before workflow advancement, add a note to your Bubble UI indicating these requirements.

### Repeating Group shows one item with all data nested instead of individual content item rows

Cause: The Data path in the Get Content Items call is not set to 'value'. Kentico's Management API wraps results in a 'value' array inside the root response — without the Data path, Bubble sees the entire response as a single item.

Solution: Open the Get Content Items call in the API Connector. Find the 'Data path' field and enter 'value'. Save the call. The Repeating Group will now correctly bind to individual content item objects in the value array.

## Frequently asked questions

### Do I need a Kentico license to use this integration?

Yes. Kentico Xperience requires an enterprise license starting around $36,000 per year — there is no free tier for production use (trial licenses are available for evaluation). This integration guide assumes your organization already has a Kentico installation. If you are starting a new content management project for a Bubble app, consider WordPress, Ghost, or another headless CMS instead — they are dramatically less expensive and simpler to integrate.

### Why does the API path need to be confirmed with a developer? Can't I just try /api/v1?

Kentico's Management API route is configured in the .NET application's routing setup and is not standardized across installations. Different Kentico deployments use different base paths. The consequence of guessing wrong is a 404 error in Bubble that looks identical to an auth error — you could spend hours debugging the wrong variable. Always confirm the path from the actual deployment configuration. Your Kentico developer can check appsettings.json or the ASP.NET routing setup in minutes.

### What is the If-Match header and why is it required for PATCH requests?

The If-Match header is Kentico's optimistic locking mechanism. When you PATCH a content item, you must prove you read the latest version of that item by including its last_modified timestamp as the If-Match value. If another user modified the item between your read and your update, your last_modified will be stale, and Kentico returns 409 Conflict to prevent you from accidentally overwriting someone else's changes. This is standard REST API optimistic concurrency control — the solution is always to re-fetch the item immediately before patching.

### Can this integration be used on Bubble's Free plan?

Basic read operations (listing content items, fetching variants, reading workflow states) work on Bubble's Free plan. Workflow transitions triggered by user button clicks also work on Free. What does not work on Free: scheduled Backend Workflows (for recurring bulk operations or automated tasks) and the iterative Backend Workflow pattern needed for processing multiple items in a batch. For the primary editorial queue use case, the Free plan is sufficient for individual item management.

### What Kentico versions does this integration support?

This guide covers Kentico Xperience by Kentico (XbyK) — the current generation platform. The Management API structure described here (/api/v1/content-items) applies to XbyK. The older Kentico 12 and Kentico 13 (K11/K12/K13) platforms use a completely different API path structure. Confirm with your developer which Kentico generation your installation is running before configuring the API Connector.

### How should non-technical editorial users access this Bubble tool?

Create a restricted Bubble page (e.g., kentico-queue) with Bubble's built-in authentication. Use Bubble's Privacy settings to require a logged-in user with a specific role (e.g., 'Editor') to see the page. Set up a simple username/password login or use Bubble's built-in auth providers. Brief your editorial team on the specific actions available (content list, workflow advance, title update) — the Bubble app should be simpler than Kentico admin, which is the point of building it.

---

Source: https://www.rapidevelopers.com/bubble-integrations/kentico
© RapidDev — https://www.rapidevelopers.com/bubble-integrations/kentico