Migrating from Canva Connect API to IMG.LY SDK: A Practical Implementation Guide

If you’re reading this, you’ve probably hit Canva Connect API’s walls.

Maybe you need deeper UI customization than Canva allows. Maybe you’re tired of Canva branding in your product. Maybe you need offline editing, server-side automation, or deployment flexibility that Canva’s cloud-only model can’t provide.

This guide is for teams currently using Canva Connect API who need a clear path to migrate to IMG.LY’s CreativeEditor SDK (CE.SDK). We’ll walk through the decision framework, feature mapping, step-by-step migration process, code comparisons, timeline estimates, and risk mitigation strategies. This isn’t about whether you should migrate; it’s about how to execute the migration with minimal disruption to your product and users. Need more reasons to switch to IMG.LY? Check out our customer report with real numbers and feedback about implementation and working with IMG.LY.

We’ve worked with teams who’ve made this transition. Some ran both systems in parallel during cutover. Others migrated user segments gradually. All of them needed a clear implementation plan that addressed technical migration, user experience continuity, and rollback options. That’s what this guide provides.

If you’re only looking for a Canva Connect alternative, check out this guide.

Updated September 2026.

Executive Summary: What This Migration Involves

Who this guide is for: Development teams, product managers, and technical decision-makers currently using Canva Connect API who need more control, customization, or deployment flexibility than Canva provides.

Why teams migrate: Canva Connect API works well for handing design work to Canva’s branded experience. Teams migrate when they need white-label customization, offline support, server-side rendering, headless automation, or infrastructure control that Canva’s SaaS model doesn’t offer.

What changes: You’re moving from a cloud-dependent, Canva-hosted editor to an SDK that runs on your infrastructure. This shift gives you complete control over UI, branding, deployment, and data, but requires more technical integration upfront.

Migration complexity: Moderate to significant, depending on how deeply Canva Connect API is integrated into your product. A production CE.SDK integration, themed and wired to your data, is typically days to a few weeks depending on scope, and our impact report puts the median at 14 days to a production-ready editor. Recreating a large template library or moving users across in stages adds to that. Many teams start with one of CE.SDK’s editor UI configurations and only customize as needs evolve. You don’t need to build everything from scratch on day one.

Key benefit: Complete control over editing experience, UI customization, branding, deployment options (client-side or server-side), offline capabilities, and data ownership, without vendor lock-in to Canva’s roadmap or infrastructure.

When Migration Makes Sense (Canva-Specific Pain Points)

Not every Canva Connect API user needs to migrate. Here are the specific limitations that typically trigger the decision:

You’ve hit Canva’s customization ceiling. Canva Connect API gives you access to Canva’s editor, but you can’t modify the core interface, remove Canva branding completely, or build custom editing workflows. If your product needs deep UI customization or a fully white-labeled experience, Canva’s constraints become blockers.

Canva branding conflicts with your brand identity. While Canva offers some branding customization, users still know they’re using Canva. If you’re building a product where editing needs to feel native (not like an embedded third-party tool), the Canva branding creates friction.

You need offline editing capabilities. Canva Connect API requires internet connectivity. If your users need to work offline (on planes, in areas with unreliable connectivity, or in secure environments without external network access), Canva’s cloud-dependent architecture won’t work.

Server-side automation is critical. Canva Connect API focuses on user-driven editing through their interface. If you need headless automation, batch processing, or programmatic generation on your servers without user interaction, you’ll struggle with Canva’s SaaS model.

Data ownership and infrastructure control matter. Canva Connect API runs on Canva’s infrastructure, which means your creative data flows through their systems. If data sovereignty, compliance requirements, or complete infrastructure control are important, Canva’s model introduces dependencies you can’t eliminate.

You need deployment flexibility across platforms. Canva Connect API is web-focused. If you need native mobile SDKs, desktop applications, or server-side rendering with the same editing engine and consistent output, Canva’s platform coverage has gaps.

If two or more of these pain points resonate, migration probably makes sense. If Canva Connect API meets your needs and you don’t face these limitations, there’s no compelling reason to migrate.

What You’ll Gain from Migration

Moving from Canva Connect API to IMG.LY CE.SDK unlocks capabilities that Canva’s architecture keeps on their side. Here’s what changes:

Complete white-label control. Remove all vendor branding, customize every UI component, match your design system precisely, or build entirely custom interfaces using the headless API. Your editing experience looks and feels like a native part of your product, not an embedded third-party tool.

Offline editing support. After initial SDK load, users can edit, export, and work with templates completely offline. No internet dependency for core editing functionality, which matters for mobile apps, travel scenarios, or secure environments.

Server-side rendering and automation. Run the same rendering engine on your Node.js servers for programmatic asset generation. Create thousands of personalized variants from templates, integrate with marketing automation platforms, or build batch processing workflows, all without user interaction. On a server the package depends on the output you need: @cesdk/node covers images and PDF, while video export needs either @cesdk/node-native or the CE.SDK Renderer, our GPU-accelerated Linux rendering engine, shipped as a Docker container you run on your own infrastructure.

Full infrastructure control. The SDK runs entirely on your infrastructure (client-side in browsers/mobile apps or server-side in your Node.js environment). You control data flow, storage, processing, and compliance. No creative assets or user data flows through IMG.LY’s servers unless you explicitly choose external integrations like Getty Images, Unsplash, or Pexels.

Cross-platform consistency. Deploy the same editing capabilities across web (JavaScript, React, Vue, Angular, Svelte), native mobile (iOS, Android, React Native, Flutter), desktop (Electron), and server (Node.js). The underlying C++ rendering engine produces identical output for the features each platform supports.

Headless architecture flexibility. Use the SDK three ways: full pre-built UI for out-of-the-box editing, custom UI built on the engine APIs, or pure headless mode for programmatic generation without any UI. Mix approaches as needed, using the visual editor for template creation and the headless API for automated generation.

Success Story: Halio

Halio, a UK-based SaaS platform helping financial advisors create and manage social media content, built its content by hand in general-purpose tools like Canva. The process couldn’t scale to meet growing client demand for consistent, branded content.

After moving that workflow into IMG.LY CE.SDK, Halio unlocked scalable, automated content generation integrated directly into their platform. Mark Lamb, Co-founder of Halio, explained the impact:

“Our users love the fact that they can either just edit an existing template…or go in and build it themselves. It’s super easy.”

The flexibility to support both template-driven workflows and custom creation (combined with complete white-label control) gave Halio the editing experience they needed without Canva’s limitations. Read the full Halio case study to see how they implemented CE.SDK across their platform.

Pre-Migration Checklist

Before starting technical migration work, document your current implementation and plan your approach:

Audit Current Canva Integration

Map all Canva Connect API touchpoints. Identify every place in your codebase where you call Canva’s REST API, create or autofill designs, hand users off to Canva to edit, or handle exports. Document request parameters, OAuth scopes, and integration points.

Document current user workflows. How do users currently interact with Canva’s editor? What editing features do they use most? Which capabilities are business-critical vs. nice-to-have? Understanding actual usage patterns helps prioritize migration work.

Catalog existing designs and templates. How many templates do users have? Are they stored in Canva’s system or yours? Do you programmatically generate designs, or is everything user-created? You’ll need a strategy for migrating or recreating these assets.

Identify customization gaps. What do you wish you could customize in Canva but can’t? What UI elements feel out of place? What features do users request that Canva doesn’t support? These become your migration opportunity list.

Assess Technical Dependencies

Review authentication integration. How does your authentication system work with Canva? Do you pass user tokens? How are permissions managed? IMG.LY’s SDK authentication model differs from Canva’s, so you’ll need to adapt.

Map asset storage and delivery. Where do images, fonts, and media assets currently live? How does Canva access them? CE.SDK can integrate with cloud storage, CDNs, or local asset libraries, but you’ll need to configure these connections.

Document export workflows. What happens after users finish editing? Where do exported assets go? How are they processed, stored, or delivered? Ensure your export pipeline can handle CE.SDK’s output formats and data structures.

Evaluate infrastructure requirements. If you plan to use server-side rendering for automation, do you have Node.js infrastructure? For GPU-accelerated video rendering, do you have access to Linux servers with GPU support? For mobile apps, do you have native development capabilities?

Conceptual Model Shift: Canva vs IMG.LY

Understanding the architectural difference between Canva Connect API and CE.SDK helps clarify why certain migration steps are necessary and what new capabilities become possible.

Canva Connect API: Hosted Editing over REST

Canva Connect API (Canva Developers SDK) is a server-side REST API. You create or autofill designs over HTTP and send the user to Canva to edit them. Your application integrates by:

• Initialization: You call the REST API from your backend, authenticated with OAuth
• Authentication: Users authorize your integration against their own Canva account via OAuth, and editing happens in Canva’s environment
• Editing: All editing occurs in Canva’s cloud-hosted editor with their UI and branding
• Storage: Designs and assets live in Canva’s infrastructure (with API access)
• Export: Canva generates exports on their servers and delivers results to you
• Updates: Canva controls feature rollout, UI changes, and API evolution

This model works well for teams who want a production-ready editor without building infrastructure. The tradeoff is limited customization, Canva branding, cloud dependency, and reliance on Canva’s roadmap.

IMG.LY CE.SDK: Client-Controlled SDK

CE.SDK is a software library you integrate directly into your application that runs on your infrastructure. Your application works by:

• Initialization: You instantiate the SDK in your codebase (client-side JavaScript or server-side Node.js)
• Rendering: A C++ engine bundled with the SDK handles all rendering locally on user devices or your servers
• Editing: Users interact with UI you control (pre-built components you customize or fully custom interfaces you build)
• Storage: All data and assets remain on your infrastructure unless you choose external integrations
• Export: Rendering happens client-side (in browsers/mobile apps) or server-side (in your Node.js environment)
• Updates: You control when to upgrade SDK versions and roll out new features

This model gives you complete control over experience, branding, infrastructure, and data flow. The tradeoff is more technical integration work upfront and ongoing maintenance responsibility.

The Control Spectrum

Here’s what shifts from Canva’s control to your control:

Deployment Model Differences

Canva’s deployment: Your app → Canva’s editor (cloud) → Canva’s rendering servers → Export delivered to you

CE.SDK’s deployment (client-side): Your app → SDK embedded in your app → Rendering on user’s device → Export in your app

CE.SDK’s deployment (server-side): Your server → SDK running in Node.js → Rendering on your server → Export stored/delivered by you

This architectural shift is why migration requires more than swapping API endpoints. You’re fundamentally changing where editing and rendering happen.

Mapping Core Features: Migration Cheat Sheet

This table maps common Canva Connect API capabilities to CE.SDK equivalents. Use this as a reference when translating your Canva integration to CE.SDK.

Key API Comparison: Common Operations

Creating a design scene:

// Canva Connect API: create the design server-side, over REST
const { design } = await fetch('https://api.canva.com/rest/v1/designs', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    design_type: { type: 'preset', name: 'presentation' },
  }),
}).then((r) => r.json());
// design.urls.edit_url opens the design on canva.com

// IMG.LY CE.SDK
import CreativeEditorSDK from '@cesdk/cesdk-js';
import { initDesignEditor } from './imgly'; // copied from the design editor starter kit

const cesdk = await CreativeEditorSDK.create('#cesdk-container', {
  userId: 'user-123',
});
await initDesignEditor(cesdk); // editor UI from the design editor starter kit
await cesdk.actions.run('scene.create');

You do not need a CE.SDK license key to try it: without one the editor runs in evaluation mode and exports carry a watermark. Start a free trial to get one and set it as license in the config.

Loading a template:

// Canva Connect API: autofill a brand template, then poll the job
// Requires a user on a Canva plan with access to autofill, such as
// Canva Pro, Canva Teams or Canva Enterprise. Below Enterprise, autofill
// is metered by a preview trial quota, after which the user must upgrade.
await fetch('https://api.canva.com/rest/v1/autofills', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ brand_template_id: 'DAFVztcvd9z', data: {} }),
});

// IMG.LY CE.SDK
const scene = await cesdk.engine.scene.loadFromURL(
  'https://your-cdn.com/template.scene'
);

Exporting a design:

// IMG.LY CE.SDK
const page = cesdk.engine.scene.getCurrentPage();
if (!page) throw new Error('No page to export');
const blob = await cesdk.engine.block.export(page, {
  mimeType: 'image/png',
  targetWidth: 1920,
  targetHeight: 1080,
});

Setting dynamic content:

// Canva Connect API: no element-level API. Text is supplied as a named
// data field when autofilling a brand template.
// data: { headline: { type: 'text', text: 'New Text Content' } }

// IMG.LY CE.SDK
const textBlock = cesdk.engine.block.findByName('headline')[0];
cesdk.engine.block.setString(textBlock, 'text/text', 'New Text Content');

What Doesn’t Directly Translate

Some Canva features don’t have direct CE.SDK equivalents. Here’s what requires custom implementation:

Real-time collaboration: Canva handles multi-user editing natively. CE.SDK doesn’t include collaboration infrastructure, so you’ll implement using WebRTC, operational transforms, or your preferred real-time sync approach.

Cloud design storage: Canva stores designs in their cloud. CE.SDK doesn’t provide storage, so integrate with your existing storage systems (database, S3, etc.) to save and load scene files.

Version history: Canva tracks design versions automatically. CE.SDK ships version control and snapshots, and the engine exposes multiple history buffers, so what you own is storing the scene snapshots in your own system.

Migration Path: Step-by-Step

This section provides a phased approach to migration that minimizes risk and maintains product stability.

Phase 1: Setup and Proof of Concept

Goal: Get CE.SDK running in a test environment and validate it meets your technical requirements.

Step 1: Get access and license

• Sign up for a free trial
• Receive license key for development environment
• Review licensing model and plan for production deployment

Step 2: Setup development environment

• Install CE.SDK via npm: npm install @cesdk/cesdk-js
• Copy the editor UI configuration from the design editor starter kit, which also lists the packages it needs
• Follow quickstart documentation for your platform (React, Vue, vanilla JS, etc.)
• Initialize basic editor instance in test environment
• Confirm SDK loads and renders correctly

Step 3: Test core capabilities

• Create a simple design using the visual editor
• Export to PNG/JPG/PDF
• Load a template and modify elements programmatically
• Validate output quality matches requirements

Step 4: Evaluate gaps

• Compare Canva features your product uses vs. CE.SDK capabilities
• Identify features requiring custom implementation
• Document technical blockers or concerns
• Confirm CE.SDK meets your use case before deeper investment

Deliverable: Working proof-of-concept demonstrating CE.SDK handles your core editing workflows.

Phase 2: Template Recreation

Goal: Recreate your most critical Canva templates in CE.SDK format.

Step 1: Prioritize templates

• List all Canva templates by usage frequency
• Identify top 5-10 templates accounting for 80% of usage
• Start with highest-value templates

Step 2: Recreate or import templates in CE.SDK

• Use CE.SDK’s visual editor to rebuild templates or plugin to import
• Define variables for dynamic content (text placeholders, image slots)
• Set role-based permissions (what’s editable, what’s locked)
• Test template behavior with sample data

Step 3: Validate template outputs

• Export samples using CE.SDK
• Compare visually to Canva exports
• Verify templates work with real content variations
• Document any visual differences or limitations

Step 4: Setup template storage

• Save templates as .scene files
• Store in version-controlled repository or CDN
• Setup template loading infrastructure in your application
• Create template management system (if needed)

Deliverable: Core templates recreated in CE.SDK format and accessible in your test environment.

Phase 3: Integration Development

Goal: Build CE.SDK integration into your application with feature parity to current Canva implementation.

Step 1: Replace editor initialization

• Swap the Connect REST calls and the hand-off to Canva for CE.SDK setup inside your own app
• Configure CE.SDK with your license, user data, and settings
• Adapt authentication flow to work with CE.SDK
• Ensure editor loads in your application context

Step 2: Migrate asset integrations

• Connect CE.SDK to your asset storage (images, fonts, media)
• Configure asset libraries using Asset API
• Setup custom asset sources if needed
• Test asset loading and performance

Step 3: Rebuild export workflows

• Replace Canva export calls with CE.SDK export API
• Adapt export format handling (PNG, PDF, video)
• Update downstream systems that consume exported assets
• Test export quality, performance, file sizes

Step 4: Implement UI customization

• Customize one of CE.SDK’s editor UI configurations to match your design system
• Apply white-label theming (colors, typography, icons)
• Remove any IMG.LY branding
• Test UI responsiveness and accessibility

Step 5: Add server-side automation (if needed)

• Setup Node.js environment for headless rendering
• Implement batch generation workflows
• Configure GPU acceleration for video (if applicable)
• Test automation pipeline performance and reliability

Step 6: Build migration tools

• Create utilities to help users transition from Canva designs
• Build import tools if you can extract data from Canva exports
• Develop user communication and guidance materials
• Prepare support documentation

Deliverable: Fully functional CE.SDK integration running in staging environment with feature parity to Canva implementation.

Handling Common Migration Concerns

Teams migrating from Canva Connect API often face similar challenges. Here’s how to address the most common concerns:

“Can we migrate existing Canva designs?”

Short answer: Yes. Export them from Canva as PPTX and bring them into CE.SDK with the PPTX importer.

”What if users prefer Canva’s interface?”

Short answer: CE.SDK’s UI is highly customizable, so you can replicate Canva’s UX patterns if desired.

Practical approach:

• Customize CE.SDK’s interface to match familiar patterns
• If specific Canva features drove user preference, implement equivalents
• Gather user feedback early (during beta testing) to identify friction points
• Focus messaging on control and ownership benefits rather than forcing change

”How do we minimize workflow disruption?”

Short answer: Phased rollout with parallel systems reduces disruption.

Practical approach:

• Run Canva and CE.SDK side-by-side during transition
• Let users opt-in to new editor before forcing switch
• Migrate user segments gradually (internal users first, then beta customers, then all users)
• Maintain Canva integration as fallback during initial rollout
• Plan rollout during low-traffic periods

”What about performance differences?”

Short answer: CE.SDK runs locally, so performance characteristics differ from cloud-based Canva.

Practical approach:

• Client-side rendering means performance depends on user devices (generally fast on modern hardware)
• Server-side rendering gives you full control over performance (scale infrastructure as needed)
• Test across your actual user device distribution
• Optimize asset delivery (use CDN for fonts, images, templates)
• For complex video editing, consider GPU-accelerated server-side rendering

”How do we handle authentication changes?”

Short answer: CE.SDK doesn’t manage authentication, so integrate with your existing auth system.

Practical approach:

• CE.SDK license validation is separate from user authentication
• Use your existing authentication system (JWT, OAuth, session-based)
• Pass authenticated user context to CE.SDK during initialization
• Implement access control and permissions at application level
• No changes required to your user authentication flow

”What if we need features CE.SDK doesn’t have?”

Short answer: CE.SDK’s plugin architecture and headless API let you build custom features.

Practical approach:

• Extend functionality using CE.SDK’s plugin system
• Build custom UI components using the headless engine API
• Integrate third-party services via Asset API and custom plugins
• Work with IMG.LY’s team for complex enterprise requirements
• Evaluate whether missing features are actually used. Often they’re not critical

Unlocked Capabilities: What’s Now Possible

Once you’ve migrated from Canva Connect API to CE.SDK, you gain capabilities that Canva’s architecture couldn’t support. Here’s what becomes possible:

Complete UI Control

Build editing experiences that feel native to your product. Customize every component, button, panel, and interaction to match your design system. Or go further and use CE.SDK’s headless API to build entirely custom interfaces that don’t look anything like a traditional editor.

Example: An e-commerce platform replaces Canva’s generic editor with a product customization flow integrated directly into the product page. Users configure product options (colors, sizes, personalization) using custom UI components, while CE.SDK handles rendering and export behind the scenes.

Server-Side Automation

Generate creative assets programmatically without user interaction. Run CE.SDK in Node.js on your servers to automate design production at scale. Create thousands of personalized banners from product data, generate dynamic video campaigns, or build batch processing pipelines. Video output on a server needs @cesdk/node-native or the CE.SDK Renderer; @cesdk/node covers images and PDF.

Example: A marketing platform automatically generates A/B testing variants for ad creatives by running CE.SDK server-side. When a marketer creates a campaign, the system instantly produces 50 design variations (different headlines, images, CTAs) for testing, no manual design work required.

Offline Editing

Let users work without internet connectivity. After initial SDK load, all editing, template manipulation, and export functionality works offline. Critical for mobile apps, travel scenarios, or environments with restricted network access.

Example: A field service application lets technicians create incident reports with photos and annotations while working in areas without cell coverage. CE.SDK handles all editing and export offline, syncing when connectivity returns.

Cross-Platform Deployment

Deploy the same editing capabilities across web, native mobile, and desktop, apart from the ones not every platform carries. Use the same templates, same rendering engine, and same output quality on every platform that carries the feature. No need to build separate editing tools for each platform.

Example: A social media management tool provides consistent editing across their web dashboard (React), iOS app (native Swift), and desktop application (Electron). Templates created in the web version work identically in mobile and desktop, and exports look the same everywhere.

Infrastructure and Data Control

Keep all creative data on your infrastructure. No external dependencies, no data flowing through third-party systems (unless you choose external integrations like stock image libraries). Full control for compliance, security, and data sovereignty requirements.

Example: A healthcare company builds patient education materials with custom templates. All patient data and generated documents stay within their HIPAA-compliant infrastructure. Nothing touches external systems.

Flexible Deployment Models

Choose where rendering happens based on your needs. Render client-side for user-driven editing (no server costs, scales infinitely with users). Render server-side for automation and batch processing (control quality, performance, and infrastructure).

Example: A web-to-print company uses client-side rendering when customers design products interactively, then uses server-side rendering to generate high-resolution print-ready PDFs for production, different rendering strategies for different workflows, same SDK.

For architectural patterns and infrastructure design when implementing these capabilities, see our guide on creative automation infrastructure.

Realistic Migration Examples

Here are concrete code comparisons showing how common Canva Connect API patterns translate to CE.SDK.

Example 1: Simple Design Creation

Canva Connect API approach:

// Canva Connect is a server-side REST API (https://api.canva.com/rest),
// authenticated with OAuth. There is no editor to mount in your page.
// Requires a user on a Canva plan with access to autofill, such as
// Canva Pro, Canva Teams or Canva Enterprise. Below Enterprise, autofill
// is metered by a preview trial quota, after which the user must upgrade.
const res = await fetch('https://api.canva.com/rest/v1/autofills', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    brand_template_id: 'DAFVztcvd9z',
    title: 'Summer Sale',
    data: { headline: { type: 'text', text: 'Summer Sale' } },
  }),
});

const { job } = await res.json();
// Poll GET /v1/autofills/{job.id} until status is 'success', then send the
// user to job.result.design.urls.edit_url, which opens the design on
// canva.com. They edit there and come back; nothing renders in your product.

CE.SDK equivalent:

import CreativeEditorSDK from '@cesdk/cesdk-js';
import { initDesignEditor } from './imgly'; // copied from the design editor starter kit

const cesdk = await CreativeEditorSDK.create('#cesdk-container', {
  license: process.env.CESDK_LICENSE,
  userId: 'user-123',
});

// Add the editor UI and asset libraries
await initDesignEditor(cesdk);

// Upload what the editor's export button produces
cesdk.actions.register('exportDesign', async (options) => {
  const { blobs } = await cesdk.utils.export(options);
  await uploadToStorage(blobs[0], 'exported-design.png');
});

// Load a template
await cesdk.engine.scene.loadFromURL(
  'https://cdn.example.com/templates/banner.scene'
);

// User edits in customized interface...

// Or handle export programmatically
const page = cesdk.engine.scene.getCurrentPage();
if (!page) throw new Error('No page to export');
const blob = await cesdk.engine.block.export(page, {
  mimeType: 'image/png',
  targetWidth: 1920,
  targetHeight: 1080,
});

// Upload or save blob
await uploadToStorage(blob, 'exported-design.png');

Key differences:

• CE.SDK requires explicit scene loading (from URL or creation)
• The editor UI comes from an editor configuration, here the one the design editor starter kit ships as source files
• Export is manual (you control where files go)
• More configuration options for export quality and resolution

Example 2: Template-Based Generation with Dynamic Content

Canva Connect API approach:

// Autofill a brand template, then export. Both are asynchronous jobs.
// Requires a user on a Canva plan with access to autofill, such as
// Canva Pro, Canva Teams or Canva Enterprise. Below Enterprise, autofill
// is metered by a preview trial quota, after which the user must upgrade.
const fill = await fetch('https://api.canva.com/rest/v1/autofills', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    brand_template_id: 'DAFVztcvd9z',
    data: {
      headline: { type: 'text', text: 'Summer Sale' },
      description: { type: 'text', text: 'Save up to 50% on selected items' },
      hero: { type: 'image', asset_id: 'Msd59349ff' },
    },
  }),
}).then((r) => r.json());

const designId = await pollAutofill(fill.job.id); // GET /v1/autofills/{id}

const exportJob = await fetch('https://api.canva.com/rest/v1/exports', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ design_id: designId, format: { type: 'png' } }),
}).then((r) => r.json());
// Poll GET /v1/exports/{exportJob.job.id} for the download URLs.

CE.SDK equivalent:

import CreativeEngine from '@cesdk/node';

const engine = await CreativeEngine.init({
  license: process.env.CESDK_LICENSE,
});
await engine.scene.loadFromURL(
  'https://cdn.example.com/templates/summer-sale.scene'
);

// Look up the template's named blocks, the same fields the autofill filled
const [headlineBlock] = engine.block.findByName('headline');
const [descriptionBlock] = engine.block.findByName('description');
const [imageBlock] = engine.block.findByName('hero');

// Set dynamic text content
engine.block.setString(headlineBlock, 'text/text', 'Summer Sale');
engine.block.setString(
  descriptionBlock,
  'text/text',
  'Save up to 50% on selected items'
);

// Replace image by updating the fill's image URI
const imageFill = engine.block.getFill(imageBlock);
engine.block.setString(
  imageFill,
  'fill/image/imageFileURI',
  'https://example.com/image.jpg'
);

// Export
const pageId = engine.scene.getCurrentPage();
if (!pageId) throw new Error('No page to export');
const blob = await engine.block.export(pageId, {
  mimeType: 'image/png',
  targetWidth: 1200,
  targetHeight: 628,
});

Key differences:

• CE.SDK runs headlessly on your servers (no user interface)
• More granular control over element manipulation
• You manage storage and delivery of exported assets
• Can batch-process hundreds/thousands of variants in loops

Example 3: Custom UI Integration

Canva Connect API approach:

// There is no UI to theme. Connect has no embeddable editor, so the editing
// interface your users see is Canva's own, on canva.com, with Canva's
// branding. Brand templates constrain the design, not the interface.

CE.SDK equivalent (full control):

import CreativeEditorSDK from '@cesdk/cesdk-js';
import { initDesignEditor } from './imgly'; // copied from the design editor starter kit

const cesdk = await CreativeEditorSDK.create('#cesdk-container', {
  license: process.env.CESDK_LICENSE,
  userId: 'user-123',
});

// Start from the starter kit UI, then customize it
await initDesignEditor(cesdk);
await cesdk.actions.run('scene.create');

// Configure theme (light or dark mode)
cesdk.ui.setTheme('dark');

// Configure UI features using the Feature API
cesdk.feature.enable('ly.img.library.panel');
cesdk.feature.enable('ly.img.settings');
cesdk.feature.enable('ly.img.navigation.bar');
cesdk.feature.enable('ly.img.navigation.actions');

// Configure navigation bar using the Order API
cesdk.ui.setComponentOrder({ in: 'ly.img.navigation.bar' }, [
  'ly.img.back.navigationBar',
  'ly.img.undoRedo.navigationBar',
  'ly.img.spacer',
  'ly.img.title.navigationBar',
  'ly.img.spacer',
  'ly.img.zoom.navigationBar',
  'ly.img.preview.navigationBar',
  'ly.img.exportImage.navigationBar',
]);

// Configure panel positioning
cesdk.ui.setPanelPosition('//ly.img.panel/assetLibrary', 'left');

// Register custom export action
cesdk.actions.register('exportDesign', async (options) => {
  const { blobs } = await cesdk.utils.export(options);
  await uploadToStorage(blobs[0], 'design.png');
});

// Or build completely custom UI using headless API
const engine = cesdk.engine;

// Custom toolbar
document.querySelector('#custom-text-btn')?.addEventListener('click', () => {
  const page = engine.scene.getCurrentPage();
  if (!page) return;
  const textBlock = engine.block.create('text');
  engine.block.setString(textBlock, 'text/text', 'New Text');
  engine.block.appendChild(page, textBlock);
});

document
  .querySelector('#custom-export-btn')
  ?.addEventListener('click', async () => {
    const page = engine.scene.getCurrentPage();
    if (!page) return;
    const blob = await engine.block.export(page, {
      mimeType: 'image/png',
    });
    // Custom export handling
  });

Key differences:

• CE.SDK offers deep UI customization through configuration
• Can build entirely custom interfaces using headless engine API
• Complete control over branding, layout, and interactions
• No external branding or forced UI patterns

Example 4: Batch Asset Generation

Canva Connect API approach:

// Two asynchronous jobs per product, each needing its own polling loop.
// Requires a user on a Canva plan with access to autofill, such as
// Canva Pro, Canva Teams or Canva Enterprise. Below Enterprise, autofill
// is metered by a preview trial quota, after which the user must upgrade.
for (const product of products) {
  const fill = await fetch('https://api.canva.com/rest/v1/autofills', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${accessToken}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      brand_template_id: 'DAFVztcvd9z',
      data: {
        product_name: { type: 'text', text: product.name },
        price: { type: 'text', text: String(product.price) },
      },
    }),
  }).then((r) => r.json());

  const designId = await pollAutofill(fill.job.id); // GET /v1/autofills/{id}

  const job = await fetch('https://api.canva.com/rest/v1/exports', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${accessToken}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ design_id: designId, format: { type: 'png' } }),
  }).then((r) => r.json());

  await pollExport(job.job.id); // GET /v1/exports/{id}
}

CE.SDK equivalent (optimized for batch): this example renders images, so it runs on @cesdk/node.

import CreativeEngine from '@cesdk/node';

const engine = await CreativeEngine.init({
  license: process.env.CESDK_LICENSE,
});

// Load template once
const templateURL = 'https://cdn.example.com/templates/product-card.scene';

// Process batch
for (const product of products) {
  // Fresh scene for each product
  await engine.scene.loadFromURL(templateURL);

  // Find and populate blocks
  const nameBlock = engine.block.findByName('product_name')[0];
  const priceBlock = engine.block.findByName('price')[0];
  const imageBlock = engine.block.findByName('product_image')[0];

  engine.block.setString(nameBlock, 'text/text', product.name);
  engine.block.setString(priceBlock, 'text/text', `$${product.price}`);

  // Replace image by updating the fill
  const imageFill = engine.block.getFill(imageBlock);
  engine.block.setString(
    imageFill,
    'fill/image/imageFileURI',
    product.imageUrl
  );

  // Export
  const page = engine.scene.getCurrentPage();
  if (!page) continue;
  const blob = await engine.block.export(page, {
    mimeType: 'image/png',
  });

  // Persist it wherever your pipeline needs it
  await savePng(`${product.id}.png`, blob);
}

// Release the engine so the process can exit
engine.dispose();

Key differences:

• CE.SDK runs efficiently on servers for batch workloads
• No user interaction required, fully automated
• Can scale horizontally (multiple rendering nodes)
• GPU acceleration available for video and complex renders

Final Recommendation and Next Steps

Migrating from Canva Connect API to CE.SDK requires upfront effort, but unlocks capabilities Canva’s architecture keeps on their side: complete white-label control, offline editing, server-side automation, cross-platform consistency, and infrastructure ownership. For teams hitting Canva’s customization limits, needing deeper product integration, or requiring deployment flexibility, migration makes strategic sense.

The technical migration is straightforward. CE.SDK’s APIs are well-documented, the SDK is production-proven (powering 500M+ creations monthly), and our team provides migration support. The real effort is template recreation and user transition planning. Teams succeed when they approach migration as a phased rollout, maintain Canva as fallback during transition, and communicate changes clearly to users.

Recommended Migration Approach

If you’re ready to start migration:

1. Sign up for a free trial to access CE.SDK and begin proof-of-concept work.
2. Review CE.SDK documentation for your platform (React, Vue, native mobile, Node.js) to understand integration requirements.
3. Contact our team to discuss your specific migration scenario. We’ll help you plan approach, estimate timeline, and address technical questions.
4. Start with highest-value templates and validate they work in CE.SDK before committing to full migration.

If you’re still evaluating whether to migrate:

• Review Why building with IMG.LY makes sense for broader context on vendor comparison, cost analysis, and customer outcomes.
• Check out full comparison between IMG.LY and Canva Connect API.

Questions about your specific migration scenario? Talk to our team. We’ll help you evaluate whether migration makes sense for your use case, provide timeline estimates, and answer technical questions specific to your integration.

Hundreds of teams have migrated from various editing solutions to CE.SDK and successfully deployed in production. With proper planning, phased rollout, and clear user communication, migration minimizes disruption while unlocking capabilities that transform what your product can do.

FAQ

Can I import my existing Canva designs into CE.SDK? Yes. Export the designs from Canva as PPTX and import them with the PPTX importer, which turns each file into a fully editable CE.SDK scene with layouts, elements, and structure intact.

How long does migration typically take? Migration timelines vary by complexity. A production CE.SDK integration, themed and wired to your data, is typically days to a few weeks depending on scope, and our impact report puts the median at 14 days to a production-ready editor. On top of that, the duration depends on factors like template library size, customization requirements, user base size, and whether you need server-side automation. Teams starting with one of CE.SDK’s editor UI configurations and basic customization can migrate faster than those building fully custom interfaces.

Does CE.SDK cost more or less than Canva Connect API? Canva Connect API uses subscription-based pricing. CE.SDK is licensed on a monthly or yearly subscription, with each platform licensed separately. Total cost depends on your usage patterns, infrastructure costs if using server-side rendering, and development investment. Many teams find CE.SDK more cost-effective at scale due to infrastructure control.

Do I need to rebuild my entire UI from scratch? No. CE.SDK provides production-ready editor UI configurations that you can use immediately with minimal customization. Many teams start with one and only customize specific components as needs evolve. You can progressively enhance the interface by applying theming and branding first, then customizing individual panels, and eventually building fully custom UI only if needed. Building from scratch using the headless API is optional and typically reserved for teams with unique workflow requirements.

Can CE.SDK work offline, or does it require internet like Canva? Yes, CE.SDK fully supports offline editing after the initial SDK load. All editing, template manipulation, and export functionality works without internet connectivity. This is critical for mobile apps, travel scenarios, secure environments, or areas with unreliable connectivity. Canva Connect API requires constant internet connection, making offline editing impossible.

How does server-side rendering work with CE.SDK compared to Canva? CE.SDK runs natively in Node.js environments for headless, programmatic generation with no user interface required. You control the rendering infrastructure including cloud servers, containers, and GPU acceleration. This enables batch processing, automated variant generation, and high-volume production workflows that run at your throughput rather than inside Canva’s published rate limits. Server-side rendering uses the same templates as the visual editor, ensuring output consistency.

Is there a free trial to test CE.SDK before committing to migration? Yes. IMG.LY offers a free trial with full access to CE.SDK across web, mobile, and server platforms. Use the trial to validate capabilities, test proof-of-concept integrations, recreate templates, and confirm CE.SDK meets your technical requirements before full migration.

What support does IMG.LY provide during migration? IMG.LY provides migration guidance, technical support, architectural consultation, and code review. Enterprise plans add SLAs, dedicated onboarding, and faster response times.