Confluence to IT Glue Migration: The CTO's Technical Guide

There is no native import path from Confluence to IT Glue. Confluence is an unstructured wiki — Spaces contain Pages in a tree hierarchy, with content stored as XHTML with custom macros. IT Glue is a relational IT documentation platform — Organizations contain Configurations, Flexible Assets, Documents, Passwords, and Contacts, all linked through explicit relationships. Every migration approach requires you to transform unstructured wiki content into IT Glue's rigid, per-organization schema. Skip that transformation step and you end up with orphaned documents and broken asset links.

This guide covers the architectural differences, the real constraints of each migration method, the API rate limits on both sides, and the data mapping decisions that determine whether your migration produces a usable IT Glue instance or a formatting graveyard. If you need to export your Confluence content first, start with How to Export All Data from Confluence: Methods, Limits & Tools. If you're evaluating whether IT Glue is the right target, see IT Glue Alternatives (2026): Migration Complexity Compared.

Confluence vs. IT Glue: Core Architecture Differences

To migrate successfully, you must understand how both systems model data — and why the mismatch makes this harder than most teams expect.

Confluence is a general-purpose wiki. Content lives in Spaces, each containing a tree of Pages. Pages hold rich text stored as Confluence Storage Format — XHTML with custom XML elements for macros and layouts — plus inline images and file attachments. Confluence has no concept of "organizations," "configurations," or "assets." Everything is a page, and structure is implicit — defined by the page tree hierarchy, labels, and space keys. The REST API exposes content and search through CQL. (support.atlassian.com)

IT Glue is a structured IT documentation platform built for MSPs. Its core data model is relational: (api.itglue.com)

The fundamental mismatch: Confluence pages are freeform and hierarchical. IT Glue assets are typed, flat within their category, and relationally linked. A single Confluence space documenting "Acme Corp" might contain pages for network diagrams, server configs, passwords in tables, and SOPs — all as wiki pages. In IT Glue, those same items split across Configurations, Flexible Assets, Documents, and Passwords, each linked back to the "Acme Corp" Organization.

Why Teams Migrate from Confluence to IT Glue

The trigger is almost always an MSP maturing its documentation practice. Common scenarios:

• PSA/RMM integration requirements. IT Glue integrates natively with ConnectWise, Autotask, Datto RMM, and the broader Kaseya stack. Confluence doesn't. MSPs maintaining client documentation in Confluence hit a wall when they need credential rotation, configuration syncing, or ticket-linked documentation. (itglue.com)
• Password management consolidation. Teams storing passwords in Confluence pages — even with page-level restrictions — lack encrypted vaulting, audit trails, and OTP support. IT Glue's password engine is purpose-built for this.
• Per-client segmentation. Confluence's permission model can isolate spaces, but it doesn't enforce per-client Organization boundaries the way IT Glue does. For MSPs managing 50+ clients, IT Glue's Organization model is materially safer.
• Compliance pressure. IT Glue is SOC 2 compliant with immutable audit trails. Confluence Cloud has audit logs, but they aren't designed for the credential-access compliance workflows MSPs face.

Migration Approaches: Native Export vs. API vs. Managed Service

Four paths exist. None is painless.

Method 1: Native HTML Export + Manual Document Import

How it works: Export Confluence spaces as HTML ZIP archives (Space Settings → Content Tools → Export → HTML). Open each HTML file, copy content, and paste or upload into IT Glue Documents within the correct Organization. IT Glue's Document Importer accepts Confluence HTML, but imported files land as a single Text block, and zipped imports arrive as a flat list at the top of the folder tree. (help.itglue.kaseya.com)

When to use it: Fewer than 50 pages, minimal attachments, and the content is purely procedural documentation (SOPs, runbooks) that maps cleanly to IT Glue Documents.

Pros:

• No API access required on either side
• No code
• Works on any IT Glue plan

Cons:

• Inline images break — Confluence's HTML export stores attachments in page-ID subfolders inside the ZIP, and IT Glue cannot resolve those paths
• No relationship mapping — you manually assign each document to an Organization
• Macros render as raw HTML or disappear entirely
• Does not scale — at 200+ pages, this becomes a multi-week manual project
• HTML exports exclude blog posts and page comments (support.atlassian.com)

Method 2: API-Based Migration (Custom ETL)

How it works: Write a script that extracts content from the Confluence REST API, transforms the XHTML body into IT Glue-compatible HTML, downloads and re-hosts attachments, then pushes the content into IT Glue via its REST API. Use CQL for targeted discovery, then content and attachment endpoints for full extraction. (developer.atlassian.com)

When to use it: 100+ pages, structured data that maps to Flexible Assets, and you have a developer available for 3–6 weeks.

Pros:

• Full control over transformation logic
• Can map Confluence pages to different IT Glue object types (Documents, Flexible Assets, Configurations)
• Handles attachments programmatically — download from Confluence, upload to IT Glue
• Repeatable for incremental or phased migrations
• Supports a source-to-target ID map so reruns are safe

Cons:

• IT Glue API access may require the Enterprise plan (see the API paywall section below)
• Rate limits on both sides require throttling, backoff, and checkpointing
• Confluence macro conversion is unsolved — your script must strip, convert, or substitute every macro type
• Attachment handling triples the API call count per page

Method 3: Middleware and iPaaS (Zapier, Make, n8n)

How it works: Use a visual builder or iPaaS tool to map Confluence triggers to IT Glue actions via HTTP calls.

When to use it: Narrow, ongoing syncs — such as one labeled space into one Organization, or new pages into a staging queue for review. Not for historical migrations.

Pros:

• Faster than building full plumbing
• Good for event-driven updates
• Useful when ops owns the workflow

Cons:

• Poor fit for large backfills — middleware times out on bulk historical loads
• Cannot handle binary attachment downloads, link rewriting, or deep hierarchies reliably
• Becomes fragile if you try to turn it into a full migration engine

Method 4: Managed Migration Service

How it works: A migration partner handles extraction, transformation, attachment re-hosting, and loading. You define the mapping; they execute it.

When to use it: 500+ pages, multiple spaces mapping to different IT Glue Organizations, attachment-heavy documentation, or zero available engineering bandwidth.

Pros:

• Handles attachment re-hosting, macro stripping, and relational mapping without internal engineering
• Rate-limit management and retry logic handled automatically
• Typically faster than building and debugging a custom script

Cons:

• External cost
• Requires clear scope definition and mapping decisions upfront

Be careful with vendor claims. IT Glue's own Cross-Account Migration Service is for IT Glue-to-IT Glue migrations, not Confluence ingestion. Even mature enterprise ingestion tools that support Confluence can omit important data — Databricks documents that its Confluence connector skips attachment binaries, page comments, and archived spaces. "Supported source" does not mean full-fidelity migration. (itglue.com)

Migration Approach Comparison

The Native Export Trap: Why HTML Imports Break Images

This is the most common failure mode. The sequence looks innocent:

1. Export a Confluence space to HTML ZIP
2. Open the HTML files
3. Copy-paste into IT Glue Documents
4. Notice broken images everywhere

Root cause: Confluence's HTML export bundles attachments in subdirectories organized by page ID. Inline images reference these local paths using relative src attributes like attachments/123456/diagram.png. When this HTML is pasted into IT Glue's rich text editor, those paths resolve to nothing — IT Glue has no access to the local file structure from the ZIP.

The problem compounds with Confluence macros. An <ac:image> macro referencing an attached file gets converted to an <img> tag in the HTML export, but the attachment itself may not be included if it wasn't directly embedded in the page body. Attachments uploaded to a page but not visually embedded are silently excluded from certain export modes.

IT Glue document sections store raw HTML and rendered HTML separately. Operators have reported HTML-style document moves where image links still pointed back to the old Confluence tenant. If you are deleting or locking down the source Confluence instance, you must re-host inline images — do not trust copied references. (api.itglue.com)

Workaround: Before importing, write a script that:

1. Parses each HTML file for <img> tags
2. Resolves the src path against the ZIP's directory structure
3. Uploads each image to IT Glue via API (or a hosting service)
4. Rewrites the src attribute to the new URL

This effectively turns a "native export" into a scripted migration — which is why most teams skip the HTML path entirely for anything beyond a handful of pages.

API-Based Migration: Rate Limits and the Enterprise Paywall

IT Glue API Constraints

IT Glue's API is well-documented but gated. Key constraints: (api.itglue.com)

• Plan requirement: IT Glue's API getting-started documentation and KB articles list API access as an Enterprise-only feature ($44/user/month with a 5-user minimum). However, as of mid-2026, IT Glue's public pricing page lists API access on Basic, Select, and Enterprise plans. Treat this as a live commercial check with IT Glue sales — do not assume from marketing pages or older docs. (itglue.com)
• Rate limit: 3,000 requests per 5-minute rolling window. A 429 Too Many Requests response signals you've hit the limit. For a migration pushing 1,000 documents with 3 attachments each, that's roughly 4,000 API calls minimum — you'll hit the rate limit within the first few minutes without throttling.
• Pagination: Default page size of 50 results, maximum of 1,000 results per request.
• Payload size: 10MB maximum per request, enforced by Amazon API Gateway.
• Attachment size: IT Glue supports any file type, but individual attachments are capped at 300 MB.
• Key security: API keys don't expire automatically but are revoked after 90 days of inactivity. Keys have no IP restriction by default — a leaked key exposes your entire documentation database.

Confluence API Constraints

Confluence Cloud's rate limiting uses a points-based model — each API call consumes points based on the work performed, not a flat request count. A simple GET on a single page costs fewer points than a query returning 100 results with expansions. Points reset at the top of each UTC hour with no carry-over. Once exhausted, all requests are blocked until reset — there is no graceful degradation. (developer.atlassian.com)

Key extraction constraints:

• Bulk response caps: body.export_view and body.styled_view on bulk endpoints are capped at 25 results per page. Keep the page size small when requesting export views. (developer.atlassian.com)
• Retry guidance: Atlassian recommends exponential backoff with jitter, starting at 1 second base delay, doubling after each retry, with a maximum of 4 retries (5 total attempts).

For Confluence Data Center (self-hosted), rate limiting uses a token bucket model that admins configure. The limit applies per-node in a cluster. Default configurations often permit 10 requests per second, but this varies by instance.

Data Mapping: Translating Spaces to Organizations, Pages to Assets

This is where migrations succeed or fail. Confluence's data model is flat and implicit. IT Glue's is typed and explicit. Every Confluence page must be classified into an IT Glue object type before migration.

The practical goal is to separate narrative documentation (SOPs, runbooks, KB articles) from structured operational data (server inventories, vendor records, backup jobs). Narrative content becomes IT Glue Documents. Structured data belongs in Flexible Asset Types with Tag fields pointing to Configurations, Contacts, or other core assets.

Confluence → IT Glue Object Mapping

Field-Level Mapping for Flexible Assets

If your Confluence pages contain structured data (e.g., a "Server Documentation" template with fields for hostname, IP, OS, warranty date), you need to:

1. Define the Flexible Asset Type in IT Glue first. Admin → Flexible Asset Types → New. Create fields matching your Confluence template structure.
2. Map each Confluence field to an IT Glue field type. IT Glue supports: Text, Textbox (rich text), Checkbox, Select, Number, Date, Tag (relationship to other assets), Password, and Upload.
3. Handle type mismatches. Confluence tables store everything as HTML. An IP address in Confluence is just text — in IT Glue, it's still text, but your transformation must strip HTML formatting.

Do not migrate structured Confluence tables as flat text into IT Glue Documents. Parse the HTML table, extract the row values, and POST them as individual Flexible Asset records. More work upfront, but it produces a usable IT Glue instance.

Handling Relationships

IT Glue's Tag fields on Flexible Assets create relationships to other IT Glue objects (Organizations, Configurations, Contacts, other Flexible Assets). Confluence has no equivalent — relationships are implicit through hyperlinks between pages.

To preserve relationships:

1. Create all Organizations first
2. Create all Configurations and Contacts
3. Create Flexible Assets last, populating Tag fields with the IT Glue IDs from steps 1–2
4. Use the IT Glue API's related_items endpoint to link Documents to relevant assets

This dependency chain means you cannot do a single-pass migration. It requires at minimum three ordered passes.

Step-by-Step Migration Process

Phase 1: Audit and Scope

• Inventory all Confluence spaces in scope
• Classify each page: Document, Flexible Asset, Password, Contact, or Discard
• Count attachments per space (Space Settings → Content Tools)
• Flag pages with heavy macro usage for manual review
• Identify restricted pages, archived content, and external/public docs
• Define the IT Glue Organization structure — one canonical mapping per space
• Pick a cutover model: big bang for small static spaces, phased by client or business unit for most real projects
• Run a pilot on one representative space before touching production

Phase 2: Prepare IT Glue

• Create all target Organizations
• Define Flexible Asset Types with field schemas matching your Confluence templates
• Set up password categories if migrating credentials
• Generate an API key (Admin → Settings → API Keys) if using the API path
• Customize the IT Glue sidebar to surface the Flexible Asset Types you created — by default, new types don't appear in navigation

Phase 3: Extract from Confluence

Use CQL for discovery, then content and attachment endpoints for full extraction. Keep bulk page sizes small when requesting export views (capped at 25 results for body.export_view). (developer.atlassian.com)

import requests
import time
 
CONFLUENCE_BASE = "https://your-domain.atlassian.net/wiki"
AUTH = ("user@example.com", "api-token")
 
def get_space_pages(space_key, start=0, limit=25):
    url = f"{CONFLUENCE_BASE}/rest/api/content"
    params = {
        "spaceKey": space_key,
        "expand": "body.storage,children.attachment",
        "start": start,
        "limit": limit
    }
    resp = requests.get(url, auth=AUTH, params=params)
    if resp.status_code == 429:
        retry_after = int(resp.headers.get("Retry-After", 60))
        time.sleep(retry_after)
        return get_space_pages(space_key, start, limit)
    resp.raise_for_status()
    return resp.json()
 
def download_attachment(download_url):
    resp = requests.get(f"{CONFLUENCE_BASE}{download_url}", auth=AUTH)
    resp.raise_for_status()
    return resp.content

For targeted extraction, use CQL to narrow the source set before fetching full page bodies:

GET /wiki/rest/api/content/search?cql=type=page AND space=CLIENTOPS ORDER BY lastmodified DESC&limit=25
Authorization: Basic <base64-email-token>
Accept: application/json

Phase 4: Transform

• Strip Confluence macros from XHTML body content (<ac:structured-macro> and related elements)
• Convert <ac:image> tags to standard <img> tags
• Download all referenced attachments
• Map pages to their target IT Glue object types
• Build relationship maps (which Flexible Assets tag which Organizations/Configurations)
• Store a source-to-target ID map so reruns are safe

If you have complex macros, the same patterns apply as in other wiki migrations. See Confluence to SharePoint Migration: Methods, Limits & Macro Mapping for strategies on parsing Atlassian XML.

Phase 5: Load into IT Glue

Push content via the REST API in dependency order: Organizations first, then Configurations/Contacts, then Documents and Flexible Assets with Tag relationships.

import requests
import time
 
ITGLUE_BASE = "https://api.itglue.com"
HEADERS = {
    "x-api-key": "your-api-key",
    "Content-Type": "application/vnd.api+json"
}
 
def create_document(org_id, name, html_content, folder_id=None):
    attributes = {
        "name": name,
        "content": html_content
    }
    if folder_id:
        attributes["document-folder-id"] = folder_id
    payload = {
        "data": {
            "type": "documents",
            "attributes": attributes
        }
    }
    url = f"{ITGLUE_BASE}/organizations/{org_id}/relationships/documents"
    resp = requests.post(url, json=payload, headers=HEADERS)
    if resp.status_code == 429:
        time.sleep(5)
        return create_document(org_id, name, html_content, folder_id)
    resp.raise_for_status()
    return resp.json()

After creating documents, upload attachments and create Related Items links:

POST /documents/{document_id}/relationships/attachments
POST /flexible_assets
POST /documents/{document_id}/relationships/related_items

Phase 6: Rebuild Relationships

After all objects are created, iterate through your relationship map and create Related Items links or populate Tag fields on Flexible Assets using the IT Glue object IDs generated during Phase 5.

Phase 7: Validate

• Compare page counts per space against document/asset counts per Organization
• Spot-check 10% of pages for formatting integrity
• Verify all inline images render correctly in IT Glue — this is the highest-frequency failure point
• Confirm password records have correct values (if migrated)
• Test Flexible Asset Tag relationships
• Check one full record chain end to end: source page → target document → related assets
• Run UAT with the people who actually use the docs, not just project sponsors

Edge Cases That Break Migrations

Migrations fail in the edge cases. Plan for these specifically:

Orphaned attachments. Confluence allows attachments to exist on a page without being linked in the text. Your script must grab all child attachments via the API, not just the ones referenced in <img> tags.

Duplicate page titles. Confluence allows duplicate page titles across spaces. IT Glue Documents within the same Organization must have unique names — duplicates cause silent overwrites or errors.

Nested pages beyond two levels. IT Glue Documents support folders, but not deeply nested hierarchies. A Confluence page tree five levels deep needs to be flattened, with hierarchy preserved through naming conventions or document body links.

Embedded passwords in Confluence tables. Teams frequently store credentials in Confluence tables with columns like "Service | Username | Password." These must be parsed row-by-row and converted to individual IT Glue Password records, each linked to the correct Organization.

Internal links. Confluence pages link to each other using relative paths or page IDs. These links break in IT Glue. Your script must maintain a mapping of Confluence_Page_ID → IT_Glue_Document_ID and rewrite all internal <a> tags before the final load.

Macro-heavy pages. Pages built primarily with macros (Jira issue lists, dynamic content, Table Filter, Gliffy) produce near-empty output after macro stripping. These pages may need to be rebuilt manually in IT Glue rather than migrated.

Attachment filename collisions. Confluence allows the same filename on different pages. When re-hosting attachments in IT Glue, you need unique file references per page context to avoid overwrites.

Flexible asset import deduplication. IT Glue flexible asset imports create duplicates instead of cleanly overwriting existing records. If you rerun without a source-to-target ID map, you will create duplicates. (help.itglue.kaseya.com)

Confluence Cloud vs. Data Center API differences. The REST API endpoint structure is similar, but authentication differs (API token + Basic Auth for Cloud, PAT or session for Data Center). Rate limiting models are completely different. Scripts built for one don't work on the other without modification.

Limitations You Cannot Engineer Around

• No true custom objects in IT Glue. Flexible Assets are the closest equivalent, but they cannot replicate Confluence's arbitrary page structure. Every Flexible Asset needs a pre-defined Type with fixed fields.
• No comment migration. IT Glue Documents don't support comments. Confluence page comments are either appended to the document body or lost.
• No version history migration. IT Glue tracks document revisions, but you can't import historical versions through the API. You get the current version only.
• No label equivalent. Confluence labels provide cross-space taxonomy. IT Glue has no tagging system for Documents — only Flexible Assets support Tag fields.
• Dynamic macros are dead. Confluence macros like "Jira Issue Filter," "Children Display," or "Table Filter" rely on real-time Atlassian server rendering. They convert to static text or disappear entirely in IT Glue.
• The API paywall may be real. Without confirmed API access on your plan, API-based migration is impossible. This affects not just the migration itself, but any post-migration automation you planned.

Validation and Rollback Planning

Record count validation: Compare the number of pages per Confluence space against Documents + Flexible Assets per IT Glue Organization. Account for pages intentionally excluded (duplicates, drafts, empty pages).

Field-level sampling: For Flexible Assets, pull 10% of records via the IT Glue API and compare field values against the Confluence source. Pay special attention to date fields (timezone conversion issues), rich text (HTML stripping artifacts), and Tag fields (broken relationships).

Image audit: Open 20 randomly selected documents in IT Glue and verify all inline images render. This is the single highest-frequency failure point.

Link audit: Randomly sample 50 documents. Click every internal link to confirm nothing points back to atlassian.net.

Rollback: IT Glue does not have a bulk delete API for Documents. If the migration produces bad data, cleanup is manual — or you delete the test Organizations entirely and re-create them. Always run the first migration pass against test Organizations, not production.

Post-Migration: What to Rebuild in IT Glue

• PSA/RMM sync configuration. If Organizations are synced from a PSA (ConnectWise, Autotask), verify the migrated Organizations match before enabling sync. Conflicting records can cause data overwrites.
• Access permissions. Confluence space permissions don't migrate. Rebuild per-Organization access controls, group assignments, and password visibility rules in IT Glue.
• User training. IT Glue's navigation model (Organization → sidebar → asset type) is fundamentally different from Confluence's space/page tree. Budget time for team onboarding. Most adoption problems come from putting new structured data back into freeform Documents instead of Flexible Assets.
• Decommission Confluence. Set Confluence to read-only for 30 days before shutting off billing to ensure no data was missed.

When to Use a Managed Migration Service

Build it yourself when:

• You have fewer than 100 pages of purely procedural documentation
• You have confirmed IT Glue API access on your plan
• You have a developer available for 3–6 weeks
• Your Confluence content is lightly formatted with few macros or attachments

Hand it off when:

• Multiple Confluence spaces need to map to different IT Glue Organizations
• Attachment-heavy documentation with hundreds of inline images
• You need to convert structured Confluence templates into Flexible Asset Types
• Your team's engineering bandwidth is allocated to product work, not infrastructure
• You cannot afford a multi-week migration timeline
• You have heavy macro usage requiring manual review and conversion

The hidden cost is not just coding. It is cleanup, reruns, UAT, user retraining, and the long tail of exceptions that show up after the first pilot. Building an ETL pipeline to parse Atlassian XHTML, handle exponential backoff, and rewrite relational links requires senior engineering bandwidth. If your team's primary job is supporting clients or building product, a one-off migration is a misallocation of their time.

At ClonePartner, we handle Confluence-to-IT Glue migrations by programmatically extracting content via the Confluence API, downloading and re-hosting all inline images and attachments, converting macro-heavy XHTML into clean IT Glue-compatible HTML, and pushing content into the correct Organizations, Documents, and Flexible Assets via the IT Glue API — with rate-limit backoff logic built in. The result is a migration that preserves document relationships and attachment integrity without requiring your engineering team to build and maintain throwaway migration scripts. For a deeper look at how we approach migrations with zero downtime guarantees, or to understand how Confluence macros break during cross-platform moves, see our Confluence to SharePoint migration guide.