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.

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.

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 basic embedded editing with 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 embedded Canva 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. Expect 2-6 weeks for basic implementations, 2-4 months for complex integrations with extensive customization and user migration planning. Many teams start with CE.SDK using the default UI 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 doesn't support. 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.

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 or Unsplash.

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 ensures identical output across all platforms.

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—visual editor for template creation, headless API for automated generation.

Success Story: Halio's Migration

Halio, a UK-based SaaS platform helping financial advisors create and manage social media content, faced challenges manually creating customized assets using tools like Canva. The process couldn't scale to meet growing client demand for consistent, branded content.

After migrating to 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 initialize Canva's editor, load designs, handle exports, or interact with Canva's API. Document initialization parameters, custom configurations, 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: SaaS Embedded Editor

Canva Connect API gives you an iframe or embed that loads Canva's editor from their infrastructure. Your application integrates by:

• Initialization: You embed Canva's interface using their JavaScript SDK
• Authentication: Users authenticate through your system, but 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
const canva = await CanvaAPI.createEditor({
  apiKey: 'YOUR_API_KEY',
  container: '#editor'
});

// IMG.LY CE.SDK
const cesdk = await CreativeEditorSDK.create('#cesdk-container', {
  license: 'YOUR_LICENSE',
  userId: 'user-123'
});
await cesdk.createDesignScene();

Loading a template:

// Canva Connect API
await canva.loadDesign('canva-design-id');

// 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();
const blob = await cesdk.engine.block.export(page, {
  mimeType: 'image/png',
  targetWidth: 1920,
  targetHeight: 1080
});

Setting dynamic content:

// Canva Connect API (varies by implementation)
await canva.updateText('text-element-id', '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—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—integrate with your existing storage systems (database, S3, etc.) to save and load scene files.

Version history: Canva tracks design versions automatically. CE.SDK doesn't include versioning—implement by saving scene snapshots at intervals and storing them with your version control approach.

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 30-day 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
• 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 Canva SDK initialization with CE.SDK setup
• 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 CE.SDK's default UI 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, through a designated upcoming plugin.

"What if users prefer Canva's interface?"

Short answer: CE.SDK's UI is highly customizable—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—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—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.

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 identical editing capabilities across web, native mobile, and desktop. Use the same templates, same rendering engine, and same output quality across all platforms. 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:

import { CanvaAPI } from '@canva/connect-api';

const editor = await CanvaAPI.createEditor({
  apiKey: process.env.CANVA_API_KEY,
  container: '#editor-container',
  publishLabel: 'Export'
});

await editor.ready();

// Load a template
await editor.loadDesign('AAF_template_id');

// User edits in Canva's interface...

// Handle export
editor.on('publish', async (opts) => {
  const exported = await editor.exportDesign({ format: 'png' });
  // Handle exported.url
});

CE.SDK equivalent:

import CreativeEditorSDK from '@cesdk/cesdk-js';

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

// Register export action
cesdk.actions.register('exportDesign', async (blobs, options) => {
  // Handle exported blobs
  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();
const blob = await cesdk.engine.block.export(page, {
  mimeType: 'image/png',
  targetWidth: 1920,
  targetHeight: 1080,
  jpegQuality: 0.9
});

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

Key differences:

• CE.SDK requires explicit scene loading (from URL or creation)
• 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:

// Canva's template autofill (if available in your plan)
await canva.autofill({
  templateId: 'template_id',
  data: {
    'headline': 'Summer Sale',
    'description': 'Save up to 50% on selected items',
    'image_url': 'https://example.com/image.jpg'
  }
});

const exported = await canva.exportDesign({ format: 'png' });

CE.SDK equivalent:

// 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();
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:

// Limited UI customization
const editor = await CanvaAPI.createEditor({
  apiKey: process.env.CANVA_API_KEY,
  container: '#editor',
  brandingTheme: {
    primaryColor: '#4A90E2',
    logo: 'https://example.com/logo.png'
  }
});
// Canva's UI with minimal theming applied

CE.SDK equivalent (full control):

import CreativeEditorSDK from '@cesdk/cesdk-js';

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

// 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.setNavigationBarOrder([
  '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 (blobs, options) => {
  // Custom export handling
  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();
  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();
  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:

// Would require multiple API calls and user interaction
for (const product of products) {
  await canva.loadDesign('template_id');
  await canva.autofill({
    'product_name': product.name,
    'price': product.price,
    'image': product.imageUrl
  });
  const exported = await canva.exportDesign({ format: 'png' });
  // Handle exported design
}

CE.SDK equivalent (optimized for batch):

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();
  const blob = await engine.block.export(page, {
    mimeType: 'image/png'
  });

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 can't provide: 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 30-day 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.

Frequently Asked Questions About Migrating from Canva to CE.SDK

Can I import my existing Canva designs into CE.SDK?

Yes, with an upcoming Canva template importer you will be able to import templates directly into IMG.LY SDK.

How long does migration typically take?

Migration timelines vary by complexity: simple integrations take 2–4 weeks, moderate integrations take 6–10 weeks, and complex enterprise deployments take 3–4 months. The duration depends on factors like template library size, customization requirements, user base size, and whether you need server-side automation. Teams starting with CE.SDK's default UI and basic customization can migrate faster than those building fully custom interfaces.

Does CE.SDK cost more or less than Canva Connect API?

Pricing models differ significantly. Canva Connect API uses subscription-based pricing, while CE.SDK uses usage-based enterprise licensing that scales with active editors, export volume, and platforms. 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 and no ongoing vendor subscription fees.

Do I need to rebuild my entire UI from scratch?

No. CE.SDK provides a production-ready default UI that you can use immediately with minimal customization. Many teams start with the default UI 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 Canva's SaaS model doesn't support. 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 30-day 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 customers receive dedicated support channels, migration planning sessions, and ongoing technical account management to help ensure a smooth transition.