# How do Embeddables work?

Embeddables let you place live Coassemble content directly inside your own product, website, intranet, portal, or help centre. Instead of sending someone off to Coassemble to take a course, the course (or a builder, or an analytics dashboard) appears right inside the tool they're already in.

Each embeddable is a ready-made piece you drop into your page. There are three families: **players** for delivery, **builders** for authoring, and **analytics** for reporting. You can use one on its own or combine several.

:::info
This article covers what the embeddables are and what you need to use them. For the technical setup, including how to generate the URLs and the parameters each one accepts, see the [Coassemble developer docs](https://developers.coassemble.com/embeddables).
:::

## How embeddables work

Every embeddable loads in an iframe on your page. The source of that iframe is a secure, signed URL that you generate through the Coassemble API. This isn't a copy-paste iframe snippet, so you'll want a developer involved: your app needs a backend that stores your Coassemble API key securely and generates the signed URL each time someone loads the page. Once that's in place, the embeddable runs inside your product.

A few things worth knowing before you plan a placement:

* **Signed URLs keep content protected.** Each placement uses its own signed URL, and learner-facing players are signed per user. That keeps your content secure and lets usage be tracked cleanly.
* **View mode and edit mode.** Players, cards, lists and analytics run in view mode (take a course, browse, or read a dashboard). Builders run in edit mode (create and edit content inside your product).
* **Access is always identified.** Because a signed URL is generated for a known user, anyone who opens an embedded player becomes an Identified Recipient. Anonymous embedding isn't currently available, so an embeddable needs an identifier for the person at page load. For fully anonymous audiences, a share link is the better fit.
* **Your app can react to events.** On the Embed plans, your app can listen for in-page `postMessage` events as a learner moves through a course, and receive server-to-server webhooks when a course is created, started, or completed.

You'll need an API key to generate the signed URLs. The [developer docs](https://developers.coassemble.com/embeddables) cover keys, endpoints, and parameters in full.

## Setting one up

Embeddables are set up manually by a developer. There's no toggle in Coassemble that turns one on. Each placement is wired up through the Coassemble API.

At a high level, the setup looks like this:

1. **Create an API key** in Coassemble. See [API keys](https://help.coassemble.com/doc/api-keys-Ttc1WvuyCD).
2. **Build a small backend in your own app** that stores the key securely. Never put an API key in your front-end code, since anyone could read it there.
3. **Generate a signed URL when the page loads.** Have your backend call the Coassemble API to create a signed URL for the embeddable you want, for the specific person viewing the page.
4. **Add an iframe to your page** and point it at that signed URL. The embeddable renders inside it.
5. **Repeat per placement.** Each embeddable, and each user, gets its own signed URL.

The [developer docs](https://developers.coassemble.com/embeddables) have the exact endpoints, parameters, and code samples for each of these steps.

## The embeddable components

You choose the components you need rather than dropping in a single fixed portal.

**Delivery (players):**

* **Course Player:** an interactive course for learners to view and complete.
* **Collection Player:** a collection of courses for learners to browse and complete.

**Browsing (cards and lists):**

* **Course Card / Collection Card:** a single course or collection shown as a clickable preview card.
* **Course List / Collection List:** a browsable list of courses or collections shown as a grid of cards.

**Authoring (builders):**

* **Course Builder:** the course creation and editing tool, running inside your product.
* **Collection Builder:** the collection editor for organising and managing courses.

**Reporting (analytics):**

* **Course Analytics:** a read-only dashboard for a specific course.
* **Collection Analytics:** a read-only dashboard for a specific collection.
* **User Analytics:** a read-only dashboard for a specific user.

## What's available on your plan

Not every embeddable is on every plan. This is the part worth checking before you build, because it's easy to assume a component is available when it isn't.

| Embeddable                                             | Available from |
| :----------------------------------------------------- | :------------- |
| Course Player, Course Card, Course List                | Pulse          |
| Collection Player, Collection Card, Collection List    | Hub            |
| Course Analytics, Collection Analytics, User Analytics | Hub            |
| Course Builder, Collection Builder (edit mode)         | Embed Core     |

A few notes on that:

* **Course-level delivery starts on Pulse.** Course Player, Course Card, and Course List are the entry point for embedding.
* **Collections and analytics start on Hub.** The collection players, cards and lists come in on Hub, along with all three analytics dashboards.
* **Builders are on the Embed plans.** The edit-mode builders (Course Builder and Collection Builder) are available on Embed Core, Embed Automate, and Embed Partner. This is also where `postMessage` events and webhooks are available.
* **Visual theming on embeddables** (styling a placement with a `themeId`) is available from Embed Automate.

Flow does not include embeddables.

## Where to go next

For the full setup, including how to generate signed URLs, the parameters each embeddable accepts, and the event and webhook reference, see the [Coassemble developer docs](https://developers.coassemble.com/embeddables).

For which plan you're on and what upgrading unlocks, see [coassemble.com/pricing](https://coassemble.com/pricing).


Embeddables

Build with the Coassemble API and embeddable components.

API keys

Embed overview

Self-hosting

Tenant caps

Releases

Security & AI FAQ

Embed getting started

Developers

Getting started in 5 minutes

What is Coassemble?

Terminology

Workspace tour

Getting started FAQ

Sign up

Coassemble as an LMS

Migrate from other tools

Getting started

Supported file types

Create from a document

Create options compared

Cloud storage

Create from slides

Sources overview

Sources you build from

Folders

Creators

Transfer ownership of your workspace

Common questions: Workspaces

Managing account, workspace, and billing settings

Workspace management

Course Collections

Collections overview

Courses overview

End-user (learner) experience

Screens

Brand kit

Create from scratch

The Finish screen

Quizzes

Languages

Media: images

Which screen to use

Create a course

Course creation FAQ

Media: video

Publish a course

Themes

Manage & edit courses

Content curation

White-labeling

AI course creation

Custom fonts

Asset library

What you can build

Course links & access

Publish & share

Share to Slack

SCORM export

Sharing FAQ

Shareable templates

Email invitations

Custom domain

Embed in your product

Deploy via MCP

Where training goes

Learners & tracking

Course analytics

Link analytics

SCORM usage

Reporting FAQ

Quiz results

Sentiment

Collection analytics

Analytics overview

Report dashboard

Webhooks

API events

Write data back via MCP

Where results go

Flow

Pulse

Embed Core

Embed Automate

Embed Partner

Overage & rates

Usage limits

Payments & billing

Plans & pricing overview

Plan changes

Plans & billing

Explore best practices for sharing your knowledge.

Build the business case for Coassemble

Assessment: Best practice for quizzes

Best practices

SCORM files not loading

SCORM session errors on Apple devices

Why isn't my Embed screen working?

Common questions: Troubleshooting

What do I do if there is a bug?

Troubleshooting

Security & SOC 2

Accessibility

Our approach to AI

AI & data security

Trust

Loom

Stripe

Notion

YouTube

HubSpot

Arcade

Vimeo

Unsplash

360Learning

aNewSpring

Docebo

Integrations overview

Slack

Connect with the API

Connect your AI model

Integrations

Release notes

Updates

Resources specifically for Embed (previously referred to as Headless course creation). These are resources that previously lived on the Headless Resources Hub.

Coassemble Embed Partner Security, Data Protection & AI FAQ

Default usage caps for clients

Managing tenant caps

Accessibility guide

AI and Data Security for Coassemble Embed Partners

Coassemble vs. Articulate: Feature comparison guide for course authoring teams

Coassemble is WCAG 2.2 Level AA Conformant

Competitor analysis

Designing effective microlearning courses

How to access and interpret the Headless usage report

How to handle competitor objections when positioning your Embed solution

Guide to pricing models for Coassemble Embed and key competitor benchmarks

Sales enablement guide: Driving user adoption

Customer testimonials for Coassemble Embed course creation (sales enablement)

Our mission: Barrier-free knowledge transfer (partner-friendly positioning language)

Getting started guide

How to communicate Coassemble feature releases to your customers 

How to migrate courses from other authoring tools into Coassemble Embed

Guide to releases

Curate

AI Create

Customize

Learner experience

Self-hosting Coassemble Embed

Initial AWS requirements for self-hosting

Embed Partners

Coassemble's AI: how it builds courses, screens, quizzes, images and narration, and how you stay in control.