# Affiliate Marketing Over API
Source: https://docs.fermion.app/api-guide/affiliate-marketing-over-api

Complete guide to implementing affiliate marketing programmatically using Fermion APIs

Fermion provides a comprehensive API for implementing affiliate marketing programs programmatically. This guide walks you through the complete process of setting up and managing affiliate marketing through our APIs.

## Overview

Affiliate marketing over API allows you to:

* Create affiliate users programmatically
* Generate custom affiliate links automatically
* Track affiliate performance and conversions
* Manage affiliate commissions and payouts
* Integrate affiliate marketing into your existing systems

## Prerequisites

Before implementing affiliate marketing over API, ensure you have valid API key.

## Step 1: Create a New Affiliate User

First, create a new user account for your affiliate using the user creation API. Use this API endpoint: [https://docs.fermion.app/api-reference/user/create-new-user](https://docs.fermion.app/api-reference/user/create-new-user)

## Step 2: Generate Affiliate Custom Link

Now you can create custom affiliate link: [https://docs.fermion.app/api-reference/affiliate-marketing/create-custom-affiliate-link](https://docs.fermion.app/api-reference/affiliate-marketing/create-custom-affiliate-link)

* Once the affiliate user is created, generate a custom affiliate link for them.
* Affiliate commission can be defined on a link basis.

<Note>
  If you'd like to create custom coupon codes for your affiliate links, you
  can use the endpoint here:
  [https://docs.fermion.app/api-reference/product/create-digital-product-coupon](https://docs.fermion.app/api-reference/product/create-digital-product-coupon)
</Note>

## Step 3: Construct the Full Affiliate URL

Use the returned `affiliateLinkSlug` to construct the complete affiliate URL:

```
https://your-lms.com/a/:affiliateLinkSlug
```

## Real-time Conversion Tracking

You can set up webhooks to receive real-time conversion notifications. Go to Webhooks in your dashboard, and enable "Product purchase" webhook event.

<Info>
  If you do not see "Webhooks" in your admin dashboard, go to "Manage
  Features" > "Webhooks" and enable it.
</Info>

## Track affiliate link data

You can also call `get-affiliate-link-stats` with the `affiliateLinkSlug` you got from step 1 to get stats like sale count, clicks and amount: [https://docs.fermion.app/api-reference/affiliate-marketing/get-affiliate-link-stats](https://docs.fermion.app/api-reference/affiliate-marketing/get-affiliate-link-stats)


# Downloadable Products over API
Source: https://docs.fermion.app/api-guide/downloadable-products-over-api

Learn how to manage downloadable digital products over APIs

Fermion offers an easy-to-use API for creating and managing downloadable digital products. This guide will help you upload and publish ZIP files via API step by step.

## Overview

With Fermion's Downloadable Products API, you can:

* Create downloadable product entries through code
* Securely upload files to our cloud storage
* Process and prepare files for distribution
* Update product metadata and descriptions
* Set up and edit pricing plans
* Manage multiple versions of any downloadable product

## Prerequisites

Before you begin, make sure you have:

* A [valid Fermion API key](/api-guide/introduction#how-to-get-your-api-key)
* A ZIP file ready for upload
* Basic familiarity with HTTP requests and file uploads

<Steps>
  <Step title="Create a Downloadable Product">
    Create a new downloadable product using the `create-downloadable-product` endpoint.

    Refer to the [create-downloadable-product endpoint](/api-reference/product/create-downloadable-product) for call details.

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"fermionDigitalProductId": "prod_abc123xyz",
    		"slug": "xyz789"
    	}
    }
    ```

    <Note>
      Save the `slug` value—it's a unique, URL-friendly ID you'll use for all later API calls.
    </Note>
  </Step>

  <Step title="Get a Presigned Upload URL">
    See the [get-presigned-url-for-downloadable-product-upload](/api-reference/product/get-presigned-url-for-downloadable-product-upload) for details.

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"r2KeyForOriginalDownloadableProduct": "private-cached-downloadable-unencrypted/prod_abc123xyz/file_unique_id",
    		"presignedUrl": "https://storage.example.com/upload?signature=..."
    	}
    }
    ```

    <Warning>
      The presigned upload URL will expire in **1 hour**. Be sure to upload your file before then.
      If it expires, just request a new upload URL.
    </Warning>

    **Key Points:**

    * Save `r2KeyForOriginalDownloadableProduct`—you'll need it next
    * The upload link is one-time and time-limited for security
    * Requesting a new URL allows you to upload a new version
  </Step>

  <Step title="Upload the File via Presigned URL">
    Upload your file using a HTTP PUT request to the URL from Step 2.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X PUT \
        -H "Content-Type: application/zip" \
        --data-binary @your-product.zip \
        "https://storage.example.com/upload?signature=..."
      ```

      ```javascript JavaScript (Node.js) theme={null}
      const fs = require('fs')

      const fileBuffer = fs.readFileSync('your-product.zip')

      await fetch(presignedUrl, {
      	method: 'PUT',
      	headers: {
      		'Content-Type': 'application/zip'
      	},
      	body: fileBuffer
      })
      ```

      ```python Python theme={null}
      import requests

      with open('your-product.zip', 'rb') as f:
          file_data = f.read()

      response = requests.put(
          presigned_url,
          headers={'Content-Type': 'application/zip'},
          data=file_data
      )
      ```
    </CodeGroup>

    <Tip>
      Use the HTTP PUT method (not POST) and make sure <code>Content-Type</code> is set to <code>application/zip</code> for correct uploads.
    </Tip>
  </Step>

  <Step title="Process the Uploaded Product">
    After uploading your file, trigger processing to prepare it for distribution.

    See the [process-uploaded-downloadable-product](/api-reference/product/process-uploaded-downloadable-product).

    **Sample Request Body:**

    ```json theme={null}
    {
    	"productSlug": "xyz789",
    	"r2KeyForOriginalDownloadableProduct": "private-cached-downloadable-unencrypted/prod_abc123xyz/file_unique_id"
    }
    ```

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"downloadableProductVersionIndex": 0
    	}
    }
    ```

    **What Processing Does:**

    1. Downloads your file from storage
    2. Validates the file format and integrity
    3. Prepares the file for secure distribution
    4. Logs version metadata to your product

    <Info>
      Save the `downloadableProductVersionIndex`—you'll need it to activate (publish) this version.
    </Info>
  </Step>

  <Step title="Update Product Metadata (Optional)">
    See API docs: [update-downloadable-product-metadata](/api-reference/product/update-downloadable-product-metadata)

    **Sample Request Body:**

    ```json theme={null}
    {
    	"productSlug": "xyz789",
    	"title": "Premium Design Templates Pack",
    	"shortDescription": "Professional templates for web and print",
    	"longDescription": "This comprehensive pack includes everything you need to create stunning designs...",
    	"activeVersionIndex": 0
    }
    ```

    **Field Breakdown:**

    * `title` (optional): Product display title
    * `shortDescription` (optional): Summary for listings
    * `longDescription` (optional): Main description on product page
    * `activeVersionIndex` (optional): Which uploaded version customers see

    <Warning>
      **Important:** Set `activeVersionIndex` to the version index returned from Step 4 to activate your upload.
      Only processed downloadable product versions (`uploaded-and-processed`) can be marked active.
    </Warning>
  </Step>

  <Step title="Add Pricing (Optional)">
    To set up paid access, use the digital product pricing API.

    See docs: [create-custom-pricing-plan-for-a-product](/api-reference/product/create-custom-pricing-plan-for-a-product)
  </Step>

  <Step title="Publish & Share">
    After completing the above, your downloadable product is ready to be published by setting it to "Active."
  </Step>
</Steps>

## Complete Example: JavaScript/Node.js Workflow

Below is a full downloadable product upload example using Node.js:

```javascript theme={null}
const API_KEY = 'your-api-key'
const BASE_URL = 'https://your-school.fermion.app/api'

// Step 1: Create the downloadable product
const createResponse = await fetch(`${BASE_URL}/public/create-downloadable-product`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		downloadableProductName: 'My Premium Templates',
		shortDescription: 'Professional design templates',
		status: 'Draft'
	})
})

const { slug, fermionDigitalProductId } = (await createResponse.json()).data

// Step 2: Request presigned upload URL
const uploadUrlResponse = await fetch(`${BASE_URL}/public/get-presigned-url-for-downloadable-product-upload`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({ productSlug: slug })
})

const { presignedUrl, r2KeyForOriginalDownloadableProduct } = (await uploadUrlResponse.json()).data

// Step 3: Upload the file
const fileBuffer = fs.readFileSync('./my-product.zip')
await fetch(presignedUrl, {
	method: 'PUT',
	headers: { 'Content-Type': 'application/zip' },
	body: fileBuffer
})

// Step 4: Process the uploaded file
const processResponse = await fetch(`${BASE_URL}/public/process-uploaded-downloadable-product`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		productSlug: slug,
		r2KeyForOriginalDownloadableProduct
	})
})

const { downloadableProductVersionIndex } = (await processResponse.json()).data

// Step 5: Update metadata and activate version
await fetch(`${BASE_URL}/public/update-downloadable-product-metadata`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		productSlug: slug,
		title: 'My Premium Templates',
		longDescription: 'This pack includes professional templates...',
		activeVersionIndex: downloadableProductVersionIndex
	})
})

console.log(`Downloadable product created successfully! Product ID: ${fermionDigitalProductId}`)
```

## Managing Multiple Product Versions

You can upload new versions (such as updates or corrections) for the same downloadable product:

<Steps>
  <Step title="Get New Presigned Upload URL">
    Call <code>get-presigned-url-for-downloadable-product-upload</code> again to get a fresh upload URL.
  </Step>

  <Step title="Upload New File">
    Upload your new file via the new URL.
  </Step>

  <Step title="Process the Upload">
    Process the new version.
  </Step>

  <Step title="Update Version Index">
    Update <code>activeVersionIndex</code> via the metadata API to switch to the new version.
  </Step>
</Steps>

<Tip>
  Don't delete past versions—you can switch between them any time by changing <code>activeVersionIndex</code>.
</Tip>

## Related Guides

* Learn about [eBooks over API](/api-guide/ebooks-over-api) for PDF-based digital products
* Explore [affiliate marketing over API](/api-guide/affiliate-marketing-over-api) to promote your products
* Check out [user endpoints](/api-guide/using-user-endpoints) for managing customer enrollments

## Getting Help

If you get stuck or have an edge-case issue:

* See the [API Reference](https://docs.fermion.app/api-reference) for endpoint details
* Check the [Webhooks Guide](https://docs.fermion.app/webhooks) to track product purchases
* For product-specific issues, contact support and include your `fermionDigitalProductId`


# eBooks over API
Source: https://docs.fermion.app/api-guide/ebooks-over-api

Learn how to manage eBooks digital product over APIs

Fermion offers an easy-to-use API for creating and managing eBook digital products. This guide will help you upload, encrypt, and publish eBooks via API step by step.

## Overview

With Fermion’s eBook API, you can:

* Create eBook products through code
* Securely upload PDF files to our cloud storage
* Apply automatic DRM protection and encryption
* Configure watermarks and control download permissions
* Update eBook metadata and descriptions
* Set up and edit pricing plans
* Manage multiple versions of any eBook

## Prerequisites

Before you begin, make sure you have:

* A [valid Fermion API key](/api-guide/introduction#how-to-get-your-api-key)
* A PDF file ready for upload (your eBook)
* Basic familiarity with HTTP requests and file uploads

<Steps>
  <Step title="Create an eBook Product">
    Create a new eBook product using the `create-ebook-product` endpoint.

    Refer to the [create-ebook endpoint](/api-reference/product/create-ebook-product) for call details.

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"fermionDigitalProductId": "prod_abc123xyz",
    		"slug": "xyz789"
    	}
    }
    ```

    <Note>
      Save the `slug` value—it's a unique, URL-friendly ID you’ll use for all later API calls.
    </Note>
  </Step>

  <Step title="Get a Presigned Upload URL">
    See the [get-presigned-url-for-ebook-upload](/api-reference/product/get-presigned-url-for-ebook-upload) for details.

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"r2KeyForOriginalEbookPdf": "private-cached-ebook-unencrypted/prod_abc123xyz/file_unique_id",
    		"presignedUrl": "https://storage.example.com/upload?signature=..."
    	}
    }
    ```

    <Warning>
      The presigned upload URL will expire in **1 hour**. Be sure to upload your PDF before then.
      If it expires, just request a new upload URL.
    </Warning>

    **Key Points:**

    * Save `r2KeyForOriginalEbookPdf`—you’ll need it next
    * The upload link is one-time and time-limited for security
    * Requesting a new URL allows you to upload a new version
  </Step>

  <Step title="Upload the PDF via Presigned URL">
    Upload your PDF using a HTTP PUT request to the URL from Step 2.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X PUT \
        -H "Content-Type: application/pdf" \
        --data-binary @your-ebook.pdf \
        "https://storage.example.com/upload?signature=..."
      ```

      ```javascript JavaScript (Node.js) theme={null}
      const fs = require('fs')

      const pdfBuffer = fs.readFileSync('your-ebook.pdf')

      await fetch(presignedUrl, {
      	method: 'PUT',
      	headers: {
      		'Content-Type': 'application/pdf'
      	},
      	body: pdfBuffer
      })
      ```

      ```python Python theme={null}
      import requests

      with open('your-ebook.pdf', 'rb') as f:
          pdf_data = f.read()

      response = requests.put(
          presigned_url,
          headers={'Content-Type': 'application/pdf'},
          data=pdf_data
      )
      ```
    </CodeGroup>

    <Tip>
      Use the HTTP PUT method (not POST) and make sure <code>Content-Type</code> is set to <code>application/pdf</code> for correct uploads.
    </Tip>
  </Step>

  <Step title="Process and Encrypt the Uploaded eBook">
    After uploading your PDF, trigger processing and encryption.

    See the [process-uploaded-ebook](/api-reference/product/process-uploaded-ebook).

    **Sample Response:**

    ```json theme={null}
    {
    	"status": "ok",
    	"data": {
    		"ebookVersionIndex": 0
    	}
    }
    ```

    **What Processing Does:**

    1. Downloads your PDF from storage
    2. Encrypts the file with AES-128-CBC
    3. Generates encryption keys and initialization vectors
    4. Saves the encrypted eBook securely
    5. Logs encryption metadata to your product

    <Info>
      Save the `ebookVersionIndex`—you’ll need it to activate (publish) this version.
    </Info>
  </Step>

  <Step title="Update eBook Metadata and Reader Settings">
    See API docs: [update-ebook-metadata](/api-reference/product/update-ebook-metadata)

    **Sample Request Body:**

    ```json theme={null}
    {
    	"productSlug": "xyz789",
    	"title": "Introduction to Web Development",
    	"shortDescription": "Learn HTML, CSS, and JavaScript fundamentals",
    	"longDescription": "This comprehensive guide covers everything you need to know about modern web development...",
    	"activeVersionIndex": 0,
    	"isBookDownloadable": false,
    	"shouldEnableCenterWatermark": true,
    	"shouldEnableHeaderWatermark": true
    }
    ```

    **Field Breakdown:**

    * `title` (optional): eBook display title
    * `shortDescription` (optional): Summary for listings
    * `longDescription` (optional): Main description on product page
    * `activeVersionIndex` (optional): Which uploaded version readers see
    * `isBookDownloadable` (optional): Allow download of PDF file
    * `shouldEnableCenterWatermark` (optional): Show watermark in middle of pages
    * `shouldEnableHeaderWatermark` (optional): Show watermark in headers

    <Warning>
      **Important:** Set `activeVersionIndex` to the version index returned from Step 4 to activate your upload.
      Only processed eBook versions (`uploaded-and-processed`) can be marked active.
    </Warning>

    ### Watermark Options

    Watermarks protect your content from unauthorized sharing:

    * **Center Watermark**: User’s email/ID in the center of every page
    * **Header Watermark**: User info shown in each PDF header
    * Watermarks are personalized for each downloader to trace misuse

    ### Controlling Download Access

    * <code>isBookDownloadable: true</code> — Allow PDF downloads for offline reading
    * <code>isBookDownloadable: false</code> — Restrict reading to browser-only
  </Step>

  <Step title="Add Pricing (Optional)">
    To set up paid access, use the digital product pricing API.

    See docs: [create-custom-pricing-plan-for-a-product](/api-reference/product/create-custom-pricing-plan-for-a-product)
  </Step>

  <Step title="Publish & Share">
    After completing the above, your eBook is ready to be published by setting it to "Active."
  </Step>
</Steps>

## Complete Example: JavaScript/Node.js Workflow

Below is a full eBook upload example using Node.js:

```javascript theme={null}
const API_KEY = 'your-api-key'
const BASE_URL = 'https://your-school.fermion.app/api'

// Step 1: Create the eBook product
const createResponse = await fetch(`${BASE_URL}/public/create-ebook-product`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		ebookName: 'My Amazing eBook',
		shortDescription: 'Learn something awesome',
		status: 'Draft'
	})
})

const { slug, fermionDigitalProductId } = (await createResponse.json()).data

// Step 2: Request presigned upload URL
const uploadUrlResponse = await fetch(`${BASE_URL}/public/get-presigned-url-for-ebook-upload`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({ productSlug: slug })
})

const { presignedUrl, r2KeyForOriginalEbookPdf } = (await uploadUrlResponse.json()).data

// Step 3: Upload the PDF
const pdfBuffer = fs.readFileSync('./my-ebook.pdf')
await fetch(presignedUrl, {
	method: 'PUT',
	headers: { 'Content-Type': 'application/pdf' },
	body: pdfBuffer
})

// Step 4: Process and encrypt the PDF
const processResponse = await fetch(`${BASE_URL}/public/process-uploaded-ebook`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		productSlug: slug,
		r2KeyForOriginalEbookPdf
	})
})

const { ebookVersionIndex } = (await processResponse.json()).data

// Step 5: Update metadata and activate version
await fetch(`${BASE_URL}/public/update-ebook-metadata`, {
	method: 'POST',
	headers: {
		'fermion-api-key': API_KEY,
		'Content-Type': 'application/json'
	},
	body: JSON.stringify({
		productSlug: slug,
		title: 'My Amazing eBook',
		longDescription: 'This eBook will teach you...',
		activeVersionIndex: ebookVersionIndex,
		isBookDownloadable: false,
		shouldEnableCenterWatermark: true,
		shouldEnableHeaderWatermark: true
	})
})

console.log(`eBook created successfully! Product ID: ${fermionDigitalProductId}`)
```

## Managing Multiple eBook Versions

You can upload new versions (such as updates or corrections) for the same eBook:

<Steps>
  <Step title="Get New Presigned Upload URL">
    Call <code>get-presigned-url-for-ebook-upload</code> again to get a fresh upload URL.
  </Step>

  <Step title="Upload New PDF">
    Upload your new PDF via the new URL.
  </Step>

  <Step title="Process and Encrypt">
    Process and encrypt the new version.
  </Step>

  <Step title="Update Version Index">
    Update <code>activeVersionIndex</code> via the metadata API to switch to the new version.
  </Step>
</Steps>

<Tip>
  Don't delete past versions—you can switch between them any time by changing <code>activeVersionIndex</code>.
</Tip>

## Best Practices

### Security

* Always use HTTPS for every API request and upload
* Never expose your API key in frontend or client code
* Enable watermarks to discourage piracy for premium content
* Disable file downloads (`isBookDownloadable: false`) for sensitive material

### Performance

* Upload large PDFs directly to storage with the presigned URL (not through your own server)
* If the upload fails or times out, request a new presigned URL and re-upload (do not reuse old links)
* Integrate uploads asynchronously if building user-facing dashboards

### Content Organization

* Set clear and descriptive `ebookName` values for easy identification
* Keep products in `Draft` mode during setup and review
* Review the eBook reader experience before publishing as “Active”
* Use `shortDescription` for SEO/discovery and `longDescription` for full details

## Troubleshooting

### "Uploaded eBook not found" Error

You may see this in Step 4 if:

* The PDF failed to upload, or upload was incomplete
* The `r2KeyForOriginalEbookPdf` you used does not match the uploaded file
* The presigned upload URL expired

**Fix:** Request a new presigned URL and upload your PDF again.

### "You can only mark an uploaded book as active" Error

This occurs if you try to activate a version that hasn't been processed.

**Fix:** Complete Step 4 (process-uploaded-ebook), then set `activeVersionIndex`.

### Upload Timed Out

Large PDFs can sometimes time out or stall.

**Fixes:**

* Use a stable and fast internet connection
* Adjust timeout settings in your HTTP client or tool
* Compress or optimize PDFs before uploading

### Expired Upload URL

**Fix:** Simply request a new presigned URL using the API—there’s no limit to how many times you can do this.

## Getting Help

If you get stuck or have an edge-case issue:

* See the [API Reference](https://docs.fermion.app/api-reference) for endpoint details
* Check the [Webhooks Guide](https://docs.fermion.app/webhooks) to track eBook purchases
* For product-specific issues, contact support and include your `fermionDigitalProductId`

## Next Steps

* [Set up pricing plans](https://docs.fermion.app/api-reference/product/create-custom-pricing-plan-for-a-product)
* [Create coupons for your eBooks](https://docs.fermion.app/api-reference/product/create-digital-product-coupon)
* [Enroll users programmatically](https://docs.fermion.app/api-reference/user/enroll-user-into-digital-product)
* [Configure webhooks](https://docs.fermion.app/webhooks) to track purchases and enrollments


# Fermion API Documentation
Source: https://docs.fermion.app/api-guide/introduction

Complete guide to integrating with Fermion API for your education platform

Welcome to the Fermion API documentation. Fermion is an AI-native platform for modern education businesses that provides comprehensive APIs to integrate coding labs, live classes, payments, and student management into your existing systems.

## Overview

Fermion provides a complete backend infrastructure for education businesses with [100% whitelabeled solutions](https://fermion.app/) and robust API support. The platform includes:

* **Built-in AI** for instructors and students
* **[Live-streaming infrastructure](/live-classes/what-are-live-classes)** (no Zoom required)
* **[Coding labs/assessments](/creating-coding-labs/what-are-coding-labs)** with full Linux environments
* **[DRM protection](/live-classes/drm-and-watermarking)** for recorded and live videos
* **Payment processing** from 180+ countries
* **[Complete API support](/api-guide/using-user-endpoints)** for automation and integration

## How to get your API key

An **API Key** is a unique identifier that allows you to authenticate and securely connect your applications with Fermion's APIs. It ensures that only authorized users or systems can access your platform’s data and perform actions such as managing [courses](/setting-up-course/prerequisites), [live classes](/live-classes/what-are-live-classes), [coding labs](/creating-coding-labs/what-are-coding-labs) or retrieving user information. By using an API key, you can safely integrate Fermion’s backend functionality into your own systems and automate tasks without exposing your account credentials.

You can get your Fermion API key with the following steps:

<Steps>
  <Step title="Navigate to API access">
    Head over to **Settings** in your Instructor dashboard sidebar and click on **API Access**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/chrome_fsSQkboUeU.imtcrf.png)
  </Step>

  <Step title="Enable API Access">
    Toggle **Enabled** in **'Enable API access?'** section and click on **Save changes** to activate API functionality for your school.
  </Step>

  <Step title="Get your API key">
    Once API access is enabled, your unique **API Key** will be displayed. Copy this key and use it in your integrations to authenticate API requests.
  </Step>
</Steps>

<Check>
  Keep your API key secure and do not share it publicly. The API key is tied to your account and can be used to access sensitive data through the Fermion API.
</Check>


# Using User API Endpoints
Source: https://docs.fermion.app/api-guide/using-user-endpoints

Guide to Fermion User API endpoints usage and things you should know

Fermion offers a robust suite of User API endpoints, enabling you to programmatically manage users, their profiles, analytics, and more. This guide provides a detailed overview of when and how to utilize these endpoints, outlines authentication requirements, and shares best practices for seamless integration into your workflow.

## When and Why Use the User API?

The User API is particularly valuable when you need to:

* Programmatically create users from your own systems
* Retrieve or update user profile information
* Upload and manage user profile images
* Access user analytics for reporting or automation purposes
* Retrieve user gamification data such as streaks

By leveraging these endpoints, you can automate user management, synchronize data with external systems, and build custom integrations on top of Fermion.

## Identifying Users: User ID vs. Email

When interacting with the User API, you have two primary methods to identify a specific user or group of users:

* **User ID:** This is a unique identifier from your external database that you can associate with a user in the Fermion system. It does not need to contain any personally identifiable information (PII) and can simply be a unique database ID. If you choose to use a User ID, ensure that it remains unique within the Fermion platform as well.

* **Email:** Alternatively, you can use the user's email address to identify them within the Fermion system. This approach is useful if you utilize Fermion both as a Learning Management System (LMS) and via APIs. However, keep in mind that if a user updates their email address within Fermion, you must also update your records to maintain synchronization.

You may associate a User ID with a user at any time. Once associated, it is recommended to use the User ID for lookups, as this method is more stable and less prone to change than using email addresses.


# Create Custom Affiliate Link 
Source: https://docs.fermion.app/api-reference/affiliate-marketing/create-custom-affiliate-link

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-custom-affiliate-link
Create a custom affiliate link for a specific digital product with commission percentage.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get affiliate link stats 
Source: https://docs.fermion.app/api-reference/affiliate-marketing/get-affiliate-link-stats

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-affiliate-link-stats
Get stats like clicks, sales, amount of sale revenue generated, etc. from an affiliate link

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get all courses progress of a given user 
Source: https://docs.fermion.app/api-reference/analytics/get-all-courses-progress-of-a-given-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-all-courses-progress
Get all courses progress of a given user. Use this to get their progress and completion data.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 300 requests in a window of 1m.



# Get individual user course progress 
Source: https://docs.fermion.app/api-reference/analytics/get-individual-user-course-progress

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-individual-course-progress
Get individual user course progress. Use this to get their progress and completion data.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get sales data with filtering 
Source: https://docs.fermion.app/api-reference/analytics/get-sales-data-with-filtering

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-sales-data
Get sales data with revenue breakdown, filtered by month/week. This is a public API that requires a fermion API key.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 30 requests in a window of 1m.



# Get user bundle progress for all bundles 
Source: https://docs.fermion.app/api-reference/analytics/get-user-bundle-progress-for-all-bundles

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-all-bundle-progress
Get user bundle progress for all bundles. Use this to get their progress and completion data.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 120 requests in a window of 1m.



# Get user bundle progress for specific bundle 
Source: https://docs.fermion.app/api-reference/analytics/get-user-bundle-progress-for-specific-bundle

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-bundle-progress
Get user bundle progress. Use this to get their progress and completion data.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get blog information 
Source: https://docs.fermion.app/api-reference/blog/get-blog-information

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-blog-information
Get details of a single blog with this API endpoint

Rate limit: Maximum 15 requests in a window of 1m.



# Get published blogs 
Source: https://docs.fermion.app/api-reference/blog/get-published-blogs

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-blogs
Get details of all published blogs with this API

Rate limit: Maximum 15 requests in a window of 1m.



# Create course 
Source: https://docs.fermion.app/api-reference/course/create-course

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-course
Create a new course (recorded or cohort-based) for your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get assignment submissions 
Source: https://docs.fermion.app/api-reference/course/get-assignment-submissions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-assignment-submissions
Get all submissions for an assignment. Returns user email, submission timestamps, file URLs, and text input values.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get course ID from course slug 
Source: https://docs.fermion.app/api-reference/course/get-course-id-from-course-slug

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-course-id-from-course-slug
Get ID of a course from its slug

Rate limit: Maximum 15 requests in a window of 1m.



# Get course metadata by slug 
Source: https://docs.fermion.app/api-reference/course/get-course-metadata-by-slug

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-course-metadata-by-slug
Get detailed metadata of a specific course using its slug

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get data for a given course item 
Source: https://docs.fermion.app/api-reference/course/get-data-for-a-given-course-item

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-course-item-data
Get all the data for a given course item. Note that this is a sensitive action and will return data for draft/unpublished course items as well.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get localized course price 
Source: https://docs.fermion.app/api-reference/course/get-localized-course-price

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-course-price
Get price of a single course depending on the country of user requesting it

Rate limit: Maximum 60 requests in a window of 1m.



# Get published courses 
Source: https://docs.fermion.app/api-reference/course/get-published-courses

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-courses
Get details of all published courses with this API

Rate limit: Maximum 15 requests in a window of 1m.



# Get user course item result 
Source: https://docs.fermion.app/api-reference/course/get-user-course-item-result

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-course-item-result
Get result of a course item for a given user

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# List course assignments 
Source: https://docs.fermion.app/api-reference/course/list-course-assignments

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/list-assignments
Get a list of all assignments inside a course product. Returns assignment ID and title for each.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# List course items 
Source: https://docs.fermion.app/api-reference/course/list-course-items

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-published-course-information
Get published course items for an individual course

Rate limit: Maximum 15 requests in a window of 1m.



# Submit user course item 
Source: https://docs.fermion.app/api-reference/course/submit-user-course-item

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/submit-user-course-item
Submit a course item for a given user

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get DSA code execution result [batch] 
Source: https://docs.fermion.app/api-reference/dsa/get-dsa-code-execution-result-[batch]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-dsa-code-execution-result-batch
Get result of multiple DSA code execution attempts at once

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 6000 requests in a window of 1m.



# Get DSA code execution result [single] 
Source: https://docs.fermion.app/api-reference/dsa/get-dsa-code-execution-result-[single]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-dsa-code-execution-result
Get result of a single DSA code execution attempt

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 300 requests in a window of 1m.



# Request DSA code execution [batch] 
Source: https://docs.fermion.app/api-reference/dsa/request-dsa-code-execution-[batch]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/request-dsa-code-execution-batch
Request multiple DSA code executions at once. Please note that if you are running SQLite, you must pass `additionalFilesAsZip` as a ZIP file that must contain `db.sqlite` file (exact name) when unzipped

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 10000 requests in a window of 1m.



# Request DSA code execution [single] 
Source: https://docs.fermion.app/api-reference/dsa/request-dsa-code-execution-[single]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/request-dsa-code-execution
Request a single DSA code execution. Please note that if you are running SQLite, you must pass `additionalFilesAsZip` as a ZIP file that must contain `db.sqlite` file (exact name) when unzipped.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 5000 requests in a window of 1m.



# Get all forms 
Source: https://docs.fermion.app/api-reference/forms/get-all-forms

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-forms-v2
Get a list of all published forms with their name and ID

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get form submissions 
Source: https://docs.fermion.app/api-reference/forms/get-form-submissions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-form-submissions-v2
Get list of submissions for a specific form

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Add XP to user 
Source: https://docs.fermion.app/api-reference/gamification/add-xp-to-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/add-xp-to-user
Increment the XP of a given user by the given amount.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get leaderboard 
Source: https://docs.fermion.app/api-reference/gamification/get-leaderboard

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-school-leaderboard
Get leaderboard of the top ranking users in your school

Rate limit: Maximum 60 requests in a window of 1m.



# Get User Streak Data 
Source: https://docs.fermion.app/api-reference/gamification/get-user-streak-data

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-streak-data
Retrieves streak data for a given user identifier

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 360 requests in a window of 1m.



# Get user XP 
Source: https://docs.fermion.app/api-reference/gamification/get-user-xp

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-xp
Get XP of a user

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Remove XP from user 
Source: https://docs.fermion.app/api-reference/gamification/remove-xp-from-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/remove-xp-from-user
Decrement the XP of a given user by the given amount.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create new interactive coding lab 
Source: https://docs.fermion.app/api-reference/lab/create-new-interactive-coding-lab

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-interactive-coding-lab
Creates a new interactive coding lab with API. You can use this endpoint instead of creating it from GUI in fermion dashboard

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Delete interactive coding lab 
Source: https://docs.fermion.app/api-reference/lab/delete-interactive-coding-lab

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-interactive-coding-lab
Deletes an existing interactive coding lab.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get interactive lab details [bulk] 
Source: https://docs.fermion.app/api-reference/lab/get-interactive-lab-details-[bulk]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-lab-details-bulk
Get details of multiple interactive labs from their IDs

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get interactive lab details [single] 
Source: https://docs.fermion.app/api-reference/lab/get-interactive-lab-details-[single]

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-lab-details
Get details of a single interactive lab from its ID

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get lab code submission zip 
Source: https://docs.fermion.app/api-reference/lab/get-lab-code-submission-zip

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-lab-code-submission
Get a downloadable zip of a user code submission for an interactive lab

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get Lab result (interactive lab) 
Source: https://docs.fermion.app/api-reference/lab/get-lab-result-interactive-lab

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-lab-result
Get result of a single user for a given interactive lab

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get Lab result (I/O lab) 
Source: https://docs.fermion.app/api-reference/lab/get-lab-result-io-lab

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-io-lab-result
Get result of a single user for a given I/O lab

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# List all interactive labs 
Source: https://docs.fermion.app/api-reference/lab/list-all-interactive-labs

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-private-lab-library
Get a list of all interactive labs from the school's private library

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update interactive coding lab 
Source: https://docs.fermion.app/api-reference/lab/update-interactive-coding-lab

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-interactive-coding-lab
Updates an existing interactive coding lab with API. You can use this endpoint instead of updating it from GUI in fermion dashboard

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create live session 
Source: https://docs.fermion.app/api-reference/live/create-live-session

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-live-event-session
Create a new live event session that you can use to go live

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Delete live event session 
Source: https://docs.fermion.app/api-reference/live/delete-live-event-session

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-live-event-session
Delete a live event session. This operation cannot be undone.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# End live event streaming 
Source: https://docs.fermion.app/api-reference/live/end-live-event-streaming

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/end-live-event-session-streaming
Call this to end live event streaming and finalize the video. After you call this, the only possible playback mode with livestreaming would be HLS playback

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get all live events 
Source: https://docs.fermion.app/api-reference/live/get-all-live-events

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-live-events
Get details of all live events in your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 15 requests in a window of 1m.



# Get live event session caption 
Source: https://docs.fermion.app/api-reference/live/get-live-event-session-caption

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-live-event-session-caption
Get url to download captions for a live event session

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get live event session processed mp4 
Source: https://docs.fermion.app/api-reference/live/get-live-event-session-processed-mp4

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-live-event-session-processed-mp4
Get url to download processed mp4 for a live event session

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get live event session stats 
Source: https://docs.fermion.app/api-reference/live/get-live-event-session-stats

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-live-event-session-stats
Get stream and viewer stats for a live event session

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Modify live session user state 
Source: https://docs.fermion.app/api-reference/live/modify-live-session-user-state

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/modify-user-state-in-live-event-session
Add or remove people from webrtc meeting stage. This will make the user a participant or instructor in a given live stream. Use this API to make certain user(s) instructors before the stream starts.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Start live event streaming 
Source: https://docs.fermion.app/api-reference/live/start-live-event-streaming

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/start-live-event-session-streaming
Call this to begin live event streaming. After you call this, your instructors can join the meeting area

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update live event session 
Source: https://docs.fermion.app/api-reference/live/update-live-event-session

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-live-event-session
Update an existing live event session details like start time, duration, event name, etc.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Health check 
Source: https://docs.fermion.app/api-reference/misc/health-check

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/health-check
Health check for our internal system

Rate limit: Maximum 60 requests in a window of 1m.



# Request password enabled website access 
Source: https://docs.fermion.app/api-reference/misc/request-password-enabled-website-access

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/request-password-enabled-website-access
Returns a signed token that can be used to access the website. This will only work if you have set a website password in Settings > Security

Rate limit: Maximum 5 requests in a window of 1m.



# Test endpoint 
Source: https://docs.fermion.app/api-reference/misc/test-endpoint

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/test
Test endpoint to check your fermion API key

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create custom pricing plan for a product 
Source: https://docs.fermion.app/api-reference/product/create-custom-pricing-plan-for-a-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-digital-product-pricing-plan
Create a new pricing plan (one-time payment or partial payment) for a digital product using the product slug. The plan will be created in draft status.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create digital product coupon 
Source: https://docs.fermion.app/api-reference/product/create-digital-product-coupon

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-digital-product-coupon
Create a new coupon for a fermion digital product.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 10 requests in a window of 1m.



# Create downloadable product 
Source: https://docs.fermion.app/api-reference/product/create-downloadable-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-downloadable-product
Create a new downloadable digital product for your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create ebook product 
Source: https://docs.fermion.app/api-reference/product/create-ebook-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-ebook-product
Create a new ebook digital product for your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create payment link 
Source: https://docs.fermion.app/api-reference/product/create-payment-link

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-payment-link-digital-product
Create a new payment link for your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Delete digital product 
Source: https://docs.fermion.app/api-reference/product/delete-digital-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-digital-product
Delete a digital product (course, ebook, downloadable product, contest, etc.) by its product ID. This operation cannot be undone.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Delete digital product coupon 
Source: https://docs.fermion.app/api-reference/product/delete-digital-product-coupon

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-digital-product-coupon
Delete (mark as deleted) a coupon for a fermion digital product.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 10 requests in a window of 1m.



# Enroll user into digital product 
Source: https://docs.fermion.app/api-reference/product/enroll-user-into-digital-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/enroll-user-into-digital-product
Add a user enrollment into any digital product on your website

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 300 requests in a window of 1m.



# Export contest CSV report 
Source: https://docs.fermion.app/api-reference/product/export-contest-csv-report

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/export-contest-csv-report
Request generation of a CSV report for contest attempts

Rate limit: Maximum 10 requests in a window of 1m.



# Get all digital products (including unlisted/draft) 
Source: https://docs.fermion.app/api-reference/product/get-all-digital-products-including-unlisteddraft

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-products-internal
Get details of all digital products with this API. This is meant to be used internally with a fermion API key only.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 15 requests in a window of 1m.



# Get contest CSV report export data 
Source: https://docs.fermion.app/api-reference/product/get-contest-csv-report-export-data

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-contest-csv-report-export-data
Get generated contest CSV reports with download links

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get enrolled digital products 
Source: https://docs.fermion.app/api-reference/product/get-enrolled-digital-products

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-enrolled-products
Get details of all enrolled digital products for a given user

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 15 requests in a window of 1m.



# Get localized digital product price 
Source: https://docs.fermion.app/api-reference/product/get-localized-digital-product-price

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-digital-product-price
Get price of a single digital product depending on the country of user requesting it

Rate limit: Maximum 60 requests in a window of 1m.



# Get presigned URL for downloadable product upload 
Source: https://docs.fermion.app/api-reference/product/get-presigned-url-for-downloadable-product-upload

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-presigned-url-for-downloadable-product-upload
Generate a presigned URL to upload files for a downloadable product

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get presigned URL for ebook upload 
Source: https://docs.fermion.app/api-reference/product/get-presigned-url-for-ebook-upload

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-presigned-url-for-ebook-upload
Generate a presigned URL to upload ebook PDF file to S3

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get product enrolled students 
Source: https://docs.fermion.app/api-reference/product/get-product-enrolled-students

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-product-enrolled-students
Get a paginated list of students enrolled in a digital product

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get published digital products 
Source: https://docs.fermion.app/api-reference/product/get-published-digital-products

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-products
Get details of all published digital products with this API

Rate limit: Maximum 15 requests in a window of 1m.



# Process uploaded downloadable product 
Source: https://docs.fermion.app/api-reference/product/process-uploaded-downloadable-product

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/process-uploaded-downloadable-product
Mark an uploaded file as processed. Call this after uploading the file to the presigned URL.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Process uploaded ebook 
Source: https://docs.fermion.app/api-reference/product/process-uploaded-ebook

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/process-uploaded-ebook
Process and encrypt an uploaded ebook PDF file. Call this after uploading the file to the presigned URL.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update digital product coupon 
Source: https://docs.fermion.app/api-reference/product/update-digital-product-coupon

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-digital-product-coupon
Update an existing coupon for a fermion digital product.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update downloadable product metadata 
Source: https://docs.fermion.app/api-reference/product/update-downloadable-product-metadata

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-downloadable-product-metadata
Update metadata and settings for a downloadable product

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update ebook metadata 
Source: https://docs.fermion.app/api-reference/product/update-ebook-metadata

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-ebook-metadata
Update metadata and settings for an ebook product

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get course quiz submissions 
Source: https://docs.fermion.app/api-reference/quiz/get-course-quiz-submissions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-quiz-submissions
Get all quiz submissions for a course product, grouped by quiz. Returns question-wise breakdown with scores.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get quiz details 
Source: https://docs.fermion.app/api-reference/quiz/get-quiz-details

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-quiz-details
Get details of a quiz from its ID

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# List all quizzes 
Source: https://docs.fermion.app/api-reference/quiz/list-all-quizzes

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-quizzes
Get a list of all quizzes from the school's private library

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create a new playground snippet 
Source: https://docs.fermion.app/api-reference/sandbox/create-a-new-playground-snippet

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-new-playground-snippet
Create a new snippet to use as sandbox

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Start playground session 
Source: https://docs.fermion.app/api-reference/sandbox/start-playground-session

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/start-playground-session
Start a new playground session for a playground snippet

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 80 requests in a window of 1m.



# Create instructor account 
Source: https://docs.fermion.app/api-reference/user/create-instructor-account

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-instructor-account
Create a new instructor account for your school. This function is idempotent - calling it multiple times with the same email will not create duplicate accounts. If the instructor already exists, they will be added to your school if not already associated.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Create new user 
Source: https://docs.fermion.app/api-reference/user/create-new-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/create-new-user
Create a new user in the system using the unique userId from your database. Note that this function is idempotent, therefore, calling it multiple times with the same userId will not do anything.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 600 requests in a window of 1m.



# Delete user 
Source: https://docs.fermion.app/api-reference/user/delete-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-user
Delete a user by their Fermion user ID or email address. At least one of fermionUserId or userEmail must be provided.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 600 requests in a window of 1m.



# Get all instructors 
Source: https://docs.fermion.app/api-reference/user/get-all-instructors

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-all-instructors
Get details of all instructors in your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 15 requests in a window of 1m.



# Get instructor IAM permissions 
Source: https://docs.fermion.app/api-reference/user/get-instructor-iam-permissions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-instructor-iam-permissions
Get the current IAM permissions of an instructor

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get instructor permission presets 
Source: https://docs.fermion.app/api-reference/user/get-instructor-permission-presets

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-instructor-permission-presets
Get available permission presets that can be applied to instructors

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get login link for user 
Source: https://docs.fermion.app/api-reference/user/get-login-link-for-user

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-login-link-for-user
Creates a login link for user for them to login directly into fermion managed LMS. Useful when you have your own system

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 300 requests in a window of 1m.



# Get presigned URLs to upload user profile picture 
Source: https://docs.fermion.app/api-reference/user/get-presigned-urls-to-upload-user-profile-picture

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-presigned-url-for-user-profile-photo
Get URL to upload a user's profile photo. You have to make a PUT request on the "presignedUrl" to upload the picture, then call the "update-user-profile-data" api endpoint to set the user's profile picture url to the "regularUrl" returned by this resolver.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get user basic profile data 
Source: https://docs.fermion.app/api-reference/user/get-user-basic-profile-data

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-basic-profile-data
Get basic user data like name, profile photo url, username, etc. using this resolver.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get user detailed analytics data 
Source: https://docs.fermion.app/api-reference/user/get-user-detailed-analytics-data

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-detailed-analytics-data
Get detailed user data like user activities, xp, enrollments, etc. using this resolver.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get user enrollments 
Source: https://docs.fermion.app/api-reference/user/get-user-enrollments

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-enrollments
Get a list of all active digital product enrollments for a user. Identify the user using either your internal user ID or the user email address.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get user ID 
Source: https://docs.fermion.app/api-reference/user/get-user-id

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-id
Get the internal user ID for a user by looking them up via email or username. At least one of email or username must be provided.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get user upcoming live sessions 
Source: https://docs.fermion.app/api-reference/user/get-user-upcoming-live-sessions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-user-upcoming-live-sessions
Get the enrolled and scheduled live sessions for a user on the current day, exactly like the upcoming live sessions shown on the user dashboard. Identify the user using any one of: your internal user ID, the Fermion user ID, or the user email address.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Remove fermion instructor from school 
Source: https://docs.fermion.app/api-reference/user/remove-fermion-instructor-from-school

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/remove-fermion-instructor-from-school
Revoke an instructor's access to your school

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 10 requests in a window of 1m.



# Update instructor IAM permissions 
Source: https://docs.fermion.app/api-reference/user/update-instructor-iam-permissions

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-instructor-iam-permissions
Update an instructor IAM permissions using presets

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 30 requests in a window of 1m.



# Update user profile data 
Source: https://docs.fermion.app/api-reference/user/update-user-profile-data

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-user-profile-data
Update user data like name, profile photo url, username, etc. using this resolver. Useful for using built-in services like coding labs and live classes

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 300 requests in a window of 1m.



# Delete Video 
Source: https://docs.fermion.app/api-reference/video/delete-video

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/delete-video
Call this endpoint to delete a video from the system. This operation cannot be undone.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Download recorded video MP4 
Source: https://docs.fermion.app/api-reference/video/download-recorded-video-mp4

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/downloaded-recorded-video-mp4
Call this endpoint to download a video from Fermion to your external system. The file will be downloaded as MP4.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 500 requests in a window of 1h.



# Get presigned URL to upload video 
Source: https://docs.fermion.app/api-reference/video/get-presigned-url-to-upload-video

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-presigned-url-for-video-upload
Get URL to upload a video in your school. You have to make a PUT request on the "presignedUrl" to upload the video, then call the "start-processing-uploaded-video" API endpoint for our transcoder to start processing your uploaded video.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get signed URL data for live event session 
Source: https://docs.fermion.app/api-reference/video/get-signed-url-data-for-live-event-session

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-signed-url-data-for-live-event-session-playback
Get m3u8 playlist URL, decryption key and verification URL signatures for playing a Fermion live event manually. This is recommended for advanced use cases only

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get signed URL data for recorded videos 
Source: https://docs.fermion.app/api-reference/video/get-signed-url-data-for-recorded-videos

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-signed-url-data-for-recorded-video-playback
Get m3u8 playlist URL, decryption key and verification URL signatures for playing a Fermion video manually. This is recommended for advanced use cases only

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Get video from video library 
Source: https://docs.fermion.app/api-reference/video/get-video-from-video-library

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/get-video-library
Retrieve information about a video inside your video library using filter search terms

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Start processing uploaded video 
Source: https://docs.fermion.app/api-reference/video/start-processing-uploaded-video

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/start-processing-uploaded-video
Call this endpoint after "get-presigned-url-for-video-upload" endpoint for our system to start processing your uploaded video. Note that you must wait for upload of video to finish otherwise your video processing might fail.

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Update video privacy setting 
Source: https://docs.fermion.app/api-reference/video/update-video-privacy-setting

https://backend.codedamn.com/webhook/fermion-backend-openapi.yaml post /public/update-video-privacy-setting
Use this endpoint to update whether video can be played publicly, or if it requires a JWT to be played. Read more about it here: https://docs.fermion.app/docs/recorded-videos/embed-video

Authentication with the "FERMION-API-KEY" header is required to use this endpoint.

Rate limit: Maximum 60 requests in a window of 1m.



# Product Updates
Source: https://docs.fermion.app/changelog

New updates and improvements

<Update label="July 2026">
  ## User Streak Data API endpoint

  You can now retrieve gamification streak data programmatically through Fermion's API. A new endpoint allows you to access user streak information:

  * **[Get User Streak Data](https://docs.fermion.app/api-reference/public/get-user-streak-data)**: Retrieves streak data for a given user identifier. This endpoint returns whether the user has a streak today, their current active streak count, their longest active streak count, and the timestamp of when the current streak was renewed. You can identify the user using `customUserId`, `fermionUserId`, or `userEmailAddress`.

  This API endpoint enables you to integrate gamification data into your existing systems, build custom gamification dashboards, or trigger custom rewards based on streak milestones.
</Update>

<Update label="January 2026">
  ## Quiz API endpoints

  You can now retrieve quizzes and their submissions programmatically through Fermion's API. Three new endpoints allow you to access quiz data:

  * **[Get course quiz submissions](https://docs.fermion.app/api-reference/quiz/get-course-quiz-submissions)**: Retrieve all quiz submissions for a course product, grouped by quiz. This endpoint returns a question-wise breakdown with scores, including user details, submission timestamps, total scores, and detailed question-level analysis showing selected answers, correct answers, and points earned for each question.

  * **[List all quizzes](https://docs.fermion.app/api-reference/quiz/list-all-quizzes)**: Retrieve a list of all quizzes from your school's private library. This endpoint returns quiz IDs, creation dates, and titles with pagination support, making it easy to programmatically discover and work with your quizzes.

  * **[Get quiz details](https://docs.fermion.app/api-reference/quiz/get-quiz-details)**: Retrieve detailed information about a specific quiz from its ID. This endpoint returns the quiz title, creation date, and all questions with their types, titles, descriptions, explanations, and options (including which options are correct).

  These API endpoints enable you to integrate quiz data into your existing systems, automate quiz submission processing, build custom analytics dashboards, and create workflows around quiz performance and analysis.
</Update>

<Update label="December 2025">
  ### Increased stage capacity to 150 participants

  The maximum number of users who can be on Stage during a live session has been increased to **150**. This enhancement allows for larger interactive classes, panels, or events, enabling instructors and organizers to bring more participants on stage to speak, present, or share their screens.

  Learn more about managing Stage participants and permissions in [Invite to stage](/live-classes/invite-to-stage).

  ## AI Builder for custom pages

  Fermion's **AI Builder** allows you to create fully customized pages by simply describing what you want. The AI will generate a complete page for you, which you can then refine with real-time data, direct checkout links, and custom paths.

  This powerful no-code tool eliminates the need for manual HTML/CSS/JavaScript coding, making it easy for anyone to create professional landing pages in minutes. Simply navigate to **Pages & redirects → Custom pages** and click on **Edit website with AI** to get started.

  The AI Builder enables you to:

  * Describe your page in natural language
  * Let the AI generate the complete page structure and design
  * Refine the page with real-time data integration
  * Add direct checkout links with proper interlinking
  * Customize the page path and publish instantly

  For more information, see [Using AI Builder](/custom-landing-pages/using-ai-builder).

  ## Contest improvements

  Contests now support **multiple sections**, allowing you to organize questions into distinct groups. When users attempt a contest with multiple sections, they can see questions clearly separated by sections, making it easier to navigate and understand the contest structure. This feature helps organize complex contests with different question types or topics.

  For more information, see [Contest - User attempts](/contests/user-attempts).

  ## Sectional timer for contests

  You can now set individual time limits for each section of your contest using sectional timers. This helps structure your contest more effectively and ensures participants manage their time within each section.

  To set a sectional timer, click on the timer icon next to the section name and enter the maximum number of minutes allotted to that section. Once set, the time limit will be shown beneath the section name and in the sidebar timer.

  When the contest begins, users see the time remaining for each section in the sidebar, making it easy to manage their time across different sections. This feature is particularly useful for multi-section contests where different parts may require different time allocations.

  For more information, see [Set up contest](/contests/set-up-contest#sectional-timer-for-contest).

  ## Improved contest report UI

  The **Contest Report** interface has been enhanced to provide a better user experience when reviewing contest performance. The improved UI offers clearer visualization of performance metrics, including final scores, time taken, accuracy, and proctoring violations summary. Users can now more easily navigate through their results and expand individual questions to view detailed feedback.

  For more information, see [Contest - User attempts](/contests/user-attempts).

  ## Partial payment dashboard

  A new **Partial payment dashboard** is now available to help you track and manage installment payment collections. The dashboard provides comprehensive insights into your partial payment plans, including:

  * **Summary overview**: View total students enrolled in payment plans with breakdowns by status (active, completed, overdue), collection amounts within date ranges, and customizable chart date ranges
  * **Collections overview chart**: Visual representation of payment collections over time, helping you identify trends and peak collection periods
  * **Partial payment students table**: Detailed view of each student's payment progress, next installment dates, and current status

  Access the dashboard by navigating to **Dashboard → Billing and earnings → Earnings → Partial payments** tab.

  For more information, see [Partial payment dashboard](/manage-settings/partial-payment-dashboard).

  ## School Event Logs

  A new **School Event Logs** dashboard is now available to help you monitor and track all events and actions performed within your school. This comprehensive audit trail provides complete visibility into who performed what action, when it occurred, and on which resource.

  The dashboard includes:

  * **Comprehensive event tracking**: View all actions including deletions, updates, and other administrative activities
  * **Resource Type filter**: Filter events by resource type (Course Item, Live Event Session, Digital Product, Video, Payment Gateway)
  * **Actor Type filter**: Filter events by who performed them (User, Instructor, API)
  * **Detailed event information**: Each log entry shows timestamp, action, resource type, resource ID, actor type, actor user ID, and technical details
  * **Technical details view**: Access additional information including IP address and user agent for each event

  Access the dashboard by navigating to **Dashboard → Settings → School settings → School event logs**.

  This feature helps maintain accountability, troubleshoot issues, monitor for suspicious activities, and ensure compliance with regulatory requirements.

  For more information, see [School Event Logs](/manage-settings/school-event-logs).

  ## Invoice settings

  You can now customize the footer text that appears on all sales invoices sent to students upon purchase. The **Invoice settings** page allows you to add important legal information, terms and conditions references, or branding messages that will appear at the bottom of every invoice.

  Access the invoice settings by navigating to **Dashboard → Settings → School settings → Invoice settings**. You can enter custom footer text with a maximum of 500 characters, which will be displayed on all future sales invoices.

  For more information, see [Invoice settings](/manage-settings/invoice-settings).

  ## Export reports (sales & no sales)

  You can now export sales and user data from your earnings dashboard for accounting, compliance, or analytics purposes. The new **Export reports** feature provides two export types:

  * **Users with no purchase**: Export a CSV list of all registered users who have not made any purchases, useful for retargeting campaigns.
  * **Sales data**: Export all sales for a selected date range. This export includes:
    * A CSV file with your complete sales report
    * Optional PDF invoices for all sales in the period (when "Include invoice downloads" is selected)

  Access the export functionality by navigating to **Dashboard → Billing and earnings → Earnings → Exports** tab. Select your export type, configure date ranges if needed, and click **Create Export** to download your data as a ZIP file.

  This feature is useful for reconciling payments, tax compliance, deeper analysis, or retargeting users who haven't made a purchase.

  For more information, see [Earnings](/manage-settings/earnings#export-reports-sales--no-sales).

  ## Enhanced live stream recording controls

  We've added new options to improve the quality and focus of your live stream recordings and participant views:

  * **Hide tiles with no media in recording**: When enabled, participants who have both their camera and microphone turned off will not appear in session recordings when a screen or specific content is pinned. This helps create cleaner, more focused recordings by eliminating empty or inactive video tiles, ensuring viewers see only active speakers and shared content. Participants who turn on their camera or microphone will automatically reappear in the recording.

  * **Hide tiles with no media**: This option hides participants with both camera and microphone off from your view when a screen or content is pinned, helping you focus on active participants during live sessions.

  These settings can be configured from the **Settings** menu during a live session under the **General** tab. For more information, see [Livestream Settings](/live-classes/livestream-settings).

  ## Remove host privileges during live sessions

  Instructors can now revoke host privileges from other hosts during live sessions. Click the yellow shield icon next to a host's name in the participant panel to remove their host status, reverting them to regular participant status. This gives you more control over session management and allows you to adjust permissions as needed during live classes.

  For more information on managing stage permissions, see [Stage](/live-classes/invite-to-stage).

  ## AI Summary for live sessions

  Fermion now automatically generates **AI-powered summaries** of your live sessions based on the transcript. After a live session is recorded and AI captions are generated, the AI summary provides students with a comprehensive overview of key topics, concepts, and takeaways from the entire session, making it easier for them to review and understand the content without watching the entire recording.

  The AI summary appears below the video player for easy access and helps students quickly grasp the main points covered during the session. To enable this feature, ensure that AI captions are enabled for your live event, as the summary is generated automatically once the transcript is available.

  For more information, see [AI Summary](/live-classes/ai-summary).

  ## Add notes and share resources after live streams

  After your live stream ends, you can now **add notes or share additional resources** with your learners directly from the session page. This makes it easy to provide follow-up material, extra insights, or answer any outstanding questions even after the session is over.

  This feature is also available to **external mentors**, allowing guest speakers or industry experts who join your sessions to upload resources, slides, or answer questions for your students post-event. This enhances collaboration and ensures students have access to all relevant materials even after the live session concludes.

  For more information, see [What are live classes](/live-classes/what-are-live-classes).

  ## Bulk import syllabus status field

  The **bulk import syllabus via CSV** feature now supports a `status` field that allows you to control whether imported items are published or saved as drafts. You can set the `status` column to `Published` or `Draft` in your CSV file. If not specified, items will default to `Draft` status.

  For more information, see [Bulk Import Syllabus](/setting-up-course/bulk-import-syllabus).

  ## Affiliate payout dashboard

  Users can now view their accumulated affiliate commission amount in a dedicated **Affiliate Payout Dashboard** from which they can request payouts directly to their bank account. The dashboard provides:

  * **Earnings overview**: View total eligible earnings and unsettled sales at a glance
  * **Bank account management**: Configure and manage bank account details required for payouts
  * **Payout request history**: Track all payout requests with detailed breakdowns showing gross amount, TDS deductions, net payout, and status
  * **Earnings breakdown**: Expand payout requests to see individual product sales, sale dates, and commission amounts
  * **Sales data explanation**: Understand the difference between new, valid, and refunded sales through an informative accordion section
  * **Affiliate links management**: Access and manage affiliate links for all eligible products
  * **Extended product promotion**: Generate affiliate links for products you're not enrolled in (when enabled by instructors)

  Access the dashboard from your user dashboard by clicking on **Affiliate dashboard**. You must configure your bank account details before requesting payouts.

  For more information, see [Affiliate Payout Dashboard](/marketing-tools/affiliate-payout-dashboard).

  ## Assignment submission preview

  Instructors can now preview submitted assignment files directly inside Fermion without needing to download them. The **Preview button** appears next to each submitted file in the assignment submissions view, allowing you to quickly review student work.

  This feature streamlines the grading process by eliminating the need to download files for review, making it faster and more convenient to evaluate student submissions.

  For more information, see [Quiz](/setting-up-course/assignments).

  ## Quiz results and student submissions

  Instructors can now easily review student performance on quizzes through an enhanced submissions interface. To access quiz results, navigate to your **Instructor Dashboard**, open the course, and go to the **Students** tab. Click on **Overall progress** to see a snapshot of student completion and activity across all course items, including quizzes.

  From the overall progress view, you can:

  * Locate any quiz and click **View submissions** to see all student attempts
  * Filter submissions by **Attempted** or **Not Attempted** status to quickly identify who has completed the quiz
  * Expand individual student submissions to view full details of their quiz performance

  The quiz submissions page provides a comprehensive view of all student attempts, making it easier to track progress, identify students who need additional support, and review quiz performance at scale.

  For more information, see [Quiz](/setting-up-course/syllabus/quiz#how-do-i-see-quiz-results-and-student-submissions%3F).

  ## Clone sections to other courses

  You can easily reuse the structure of your course by cloning sections into other courses that you manage. This is useful for duplicating module templates, onboarding content, or lesson structures without rebuilding them manually. For more information, see [Sections and Sub-sections](/setting-up-course/syllabus#clone-sections-to-other-courses).

  ## Hide test output logs in embedded coding labs

  You can now hide test output logs in embedded coding labs by setting `shouldHideTestOutputLogs` to `true` in the playground options. By default, the output logs of the lab's challenges are shown in the embedded IDE after users run their code. When enabled, the test output logs section will be hidden from the user's view, providing a cleaner interface for students.

  For more information, see [Embedding coding labs](/creating-coding-labs/embedding-lab#shouldhidetestoutputlogs).

  ## Completion certificates

  When setting up completion certificates, you can also choose the certificate's orientation - landscape or portrait, to better fit your preferred design or branding

  For more information, see [Completion Certificates](/setting-up-course/completion-certificate).

  ## View all assignment submissions across courses

  Instructors can now view and manage all assignment submissions from a central location across all their courses. A new **New assignment submissions (last 30 days)** widget appears on your Instructor Dashboard homepage, providing quick access to recent submissions

  From the dashboard widget, click **View all** to access a dedicated page where you can:

  * View all recent assignment submissions in one place
  * Filter submissions by graded / not graded status
  * Click on any submission to review files, provide feedback, and grade
  * Download or preview submitted files (for supported file types)
  * Grade assignments with feedback and files if needed

  This central view helps you efficiently keep track of submissions and streamline your grading workflow across multiple courses.

  For more information, see [Assignments](/setting-up-course/assignments#view-all-assignment-submissions-across-all-courses).

  ## New instructor permission types

  Four new instructor permission types have been added to provide more granular control over instructor access:

  ### Bundle management access

  Instructors with **Bundle management** access can manage all bundles, including enrollment, coupons, pricing, and deletion. They can create and manage bundles, enroll students, create coupons, update pricing, and delete bundles. However, they cannot access courses or contests, billing information, webhooks, or private API keys.

  ### Object storage access

  Instructors with **Object storage access** can manage object storage by uploading, downloading, and deleting files. This permission is ideal for team members who need to manage media assets without access to course content or billing information.

  ### Community access

  Instructors with **Community access** can create and manage community channels and moderate discussions. They can create channels, edit and archive them, add/remove participants, moderate discussions and messages, and manage blacklisted users. However, they cannot access courses, billing information, webhooks, or add/remove admins.

  ### User management access

  Instructors with **User management access** can view all users, monitor course progress, and remove users from products. They can view all users in the school, view individual user course progress and activity, remove users from courses and products, and reset user course progress. However, they cannot create or edit courses, access billing information, manage webhooks, or add/remove admins.

  These new permission types allow you to delegate specific responsibilities to instructors while maintaining control over sensitive areas like billing and admin management.

  For more information, see [Manage Instructors](/manage-settings/manage-instructors).

  ## View instructor details

  You can now view detailed statistics and recent activity for each instructor to help monitor participation and performance. Click the **View details** button next to any instructor in the Manage Instructor panel to access a comprehensive summary page.

  **The instructor details page includes:**

  ### Activity metrics

  * **Live classes conducted**: The total number of live classes the instructor has hosted
  * **Hours taught**: The total live teaching hours
  * **Last active**: The most recent time the instructor was active (e.g., "2 hours ago")

  ### Live classes

  Below the activity metrics, you'll see a detailed table listing the instructor's most recent live classes. This table provides an overview of each session, including its title, scheduled and actual start times, end time, and total duration.

  These insights make it simple to monitor instructor engagement, track their teaching workload, and identify opportunities for recognition, support, or intervention. Use these details to help optimize your school's teaching resources and quality assurance.

  For more information, see [Manage Instructors](/manage-settings/manage-instructors#view-instructor-details).

  ## Instructor IAM permissions API endpoints

  You can now manage instructor permissions programmatically through Fermion's API. Three new endpoints allow you to retrieve and update instructor IAM permissions:

  * **[Get instructor IAM permissions](https://docs.fermion.app/api-reference/user/get-instructor-iam-permissions)**: Retrieve the current IAM permissions of an instructor. This endpoint returns the complete permission policy including all permission sets and resource sets assigned to the instructor.

  * **[Get instructor permission presets](https://docs.fermion.app/api-reference/user/get-instructor-permission-presets)**: Retrieve available permission presets that can be applied to instructors. This endpoint returns a list of all available presets (such as "single-course-access", "bundle-management", "object-storage-access", etc.) along with their requirements and permission sets.

  * **[Update instructor IAM permissions](https://docs.fermion.app/api-reference/user/update-instructor-iam-permissions)**: Update an instructor's IAM permissions using presets. This endpoint allows you to programmatically assign permission presets to instructors, making it easy to manage instructor access at scale through API calls.

  These API endpoints enable automated instructor permission management, making it easier to integrate Fermion's instructor management into your existing systems and workflows.

  ## Forms API endpoints

  You can now retrieve forms and their submissions programmatically through Fermion's API. Two new endpoints allow you to access form data:

  * **[Get all forms](https://docs.fermion.app/api-reference/forms/get-all-forms)**: Retrieve a list of all published forms with their name and ID. This endpoint returns all forms available in your school, making it easy to programmatically discover and work with your forms.

  * **[Get form submissions](https://docs.fermion.app/api-reference/forms/get-form-submissions)**: Retrieve all submissions for a specific form. This endpoint returns detailed submission data including submission ID, user ID, submission timestamp, and all answers provided by users, organized by form blocks.

  For more information on forms, see [Forms](/forms/introduction).
</Update>

<Update label="November 2025">
  ## AI tutor

  Empower your students with real-time, contextual assistance powered by AI! The **AI tutor** feature provides an intelligent copilot for your courses, giving learners immediate, context-aware support across quizzes, videos, and articles

  When enabled, the AI tutor appears as a copilot in the bottom-right corner of the student interface. This AI answers students' questions based on relevant course material, drawing context from:

  * **Quiz**: Understands the quiz question and related concepts
  * **Article**: Reads the article content and supplementary materials
  * **Video**: Utilizes generated video captions and transcripts

  You can enable AI tutor for any combination of these content types from **Instructor dashboard → Open any course → Select AI tutor from the sidebar**. The AI provides rich, targeted responses to boost student learning and engagement without students needing to switch tabs or wait for instructor replies.

  For more information, see [AI tutor](/setting-up-course/ai-tutor).

  ## AI Lab Builder

  Create interactive coding labs faster than ever with Fermion's **AI Lab Builder**! This powerful feature uses AI assistance to help you generate lab content, instructions, and challenges automatically based on your requirements.

  The AI Lab Builder features a natural language chat interface that understands your instructions and automatically configures your lab by invoking various tool calls. Simply describe what you need, and the AI agent will:

  * Create project files
  * Install dependencies
  * Set up challenges
  * Configure lab descriptions

  The AI Lab Builder supports multiple technologies including HTML/CSS/JavaScript, React/Springboot (Java), Next.js, Node.js, and Django (Python), with more coming soon.

  To get started, navigate to **Dashboard → Coding labs → Labs → Interactive labs**, then click **Build using AI Agent**. Enter a title, choose your preferred technology, and start chatting with the AI agent to build your lab.

  For more information, see [AI Lab Builder](/creating-coding-labs/ai-lab-builder).

  ## Enhanced course analytics

  We've enhanced the course analytics pages to provide more detailed information regarding student and course progress.

  * **[Detailed Student Report](/setting-up-course/detailed-student-report)**: Access comprehensive student analytics including performance metrics, content engagement breakdown, activity timeline, and detailed course item completion status. Learn how to view individual student reports with step-by-step instructions.

  * **[Overall Progress](/setting-up-course/overall-progress)**: Track overal student progress metrics including enrollment date, completion status, time spent, and course completion percentage. Understand how to monitor overall course advancement at a glance.

  These pages help you better understand and utilize the analytics dashboard to support your students and improve course completion rates.

  ## Digital products via API

  You can now create and manage digital products-including eBooks (PDF) and downloadable files (ZIP)-programmatically using Fermion's API. Upload files, apply DRM protection to ebooks, configure watermarks, set pricing, update metadata, and manage multiple product versions-all through API calls.

  For step-by-step instructions, see:

  * [eBooks over API](/api-guide/ebooks-over-api)
  * [Downloadable Products over API](/api-guide/downloadable-products-over-api)

  ## Blog editor LaTeX support

  The blog editor now supports LaTeX formatting, allowing you to include mathematical equations and formulas in your blog posts. This enhancement makes it easier to create educational content with complex mathematical notation, scientific formulas, and technical documentation.

  For more information on creating and managing blogs, see [Blogs](/custom-landing-pages/blogs).

  ## Instructor support chatbot

  Instructors can now reach out to Fermion support directly through the instructor dashboard using an integrated chatbot. This feature provides quick access to help and support without leaving your workspace, making it easier to get assistance with platform features, troubleshooting, and account-related questions.

  The chatbot is accessible directly from your instructor dashboard, providing instant support for common queries and the ability to escalate more complex issues to our support team : [Support channels](/onboarding/support-strategy#support-channels)

  ## Live stream optimization and animations

  We've enhanced the live streaming experience with performance optimizations and smoother animations. These improvements result in faster load times, more responsive controls, and a more polished user interface during live sessions. The optimizations ensure a better experience for both instructors and students, especially in sessions with many participants.

  For more information on live classes, see [Live Class on Fermion](/live-classes/what-are-live-classes).

  ## Customizable live stream iframe embed

  The live stream iframe embed is now fully customizable, giving you more control over how embedded live sessions appear on your website. You can customize the appearance, dimensions, and behavior of embedded live sessions to match your site's design and branding.

  For detailed instructions on embedding live sessions externally, see [Embedding live session externally](/live-classes/embed-live-session).

  ## Live stream API enhancements

  The live stream API endpoints for creating and updating live sessions have been enhanced to include a new parameter: `shouldAddEveryoneOnStageByDefault`. When set to `true`, this option will automatically add all participants to the stage when they join a live session, up to a maximum of 50 people (the stage capacity limit).

  You can use this feature via the following API endpoints:

  * [Create Live Session](https://docs.fermion.app/api-reference/live/create-live-session)
  * [Update Live Event Session](https://docs.fermion.app/api-reference/live/update-live-event-session)

  ### Live Stream Embed `window.postMessage` Events

  You can programmatically interact with an embedded live stream using `window.postMessage` events. These events enable you to control the embedded player and respond to state changes from your own application.

  **Available events include:**

  * **`play`**
    Start or resume the embedded live video.
    → See [How to control playback](/live-classes/embed-live-session#playback-controls)
  * **`pause`**
    Pause the currently playing video.
    → See [Playback controls](/live-classes/embed-live-session#playback-controls)
  * **`toggle-fullscreen`**
    Switch the embedded video to or from fullscreen mode.
    → [Read more about fullscreen support](/live-classes/embed-live-session#fullscreen)
  * **`mute`**
    Mute the audio in the embedded player.
    → [Mute and unmute events](/live-classes/embed-live-session#audio-controls)
  * **`unmute`**
    Unmute the audio in the embedded player.
    → See [Mute and unmute events](/live-classes/embed-live-session#audio-controls)
  * **`get-current-state`**
    Request the current state (playing, paused, time, etc.) from the embed.
    → [State and event information](/live-classes/embed-live-session#state-event)
  * **`seek-to`**
    Seek to a specific time (in seconds) in the video.
    → [Seeking events and usage](/live-classes/embed-live-session#seeking)

  You can find a **full reference and code examples** in [Embedding live session externally > window.postMessage Events](/live-classes/embed-live-session#window-postmessage-events).

  These events allow you to build custom controls, synchronize multiple players, or react to embed status changes from your web page or app.
  For more details, : [See the documentation](/live-classes/embed-live-session#window-postmessage-events)

  ## PhonePe payment gateway integration

  You can now integrate your own PhonePe merchant account as a custom payment gateway on Fermion. This allows payments to be credited directly to your PhonePe account, giving you full control over payment settings, reconciliation, and settlements while Fermion handles the student checkout flow and reporting.

  PhonePe supports INR payments through UPI, credit/debit cards, and wallets, providing secure payment processing and instant notifications for your business. You can configure PhonePe from **Instructor dashboard → Payment gateways**.

  For step-by-step setup instructions, see [Custom PhonePe integration](/setup-pricing/custom-payment-gateway#custom-phonepe-integration).

  ## Bulk reset progress for multiple students

  You can now reset course progress for multiple students at once from the Students tab in your course. This feature is useful when you need to allow students to retake a course or reset their progress after course content updates. Select multiple students using checkboxes and use the Actions dropdown to reset all course progress for the selected students in a single operation.

  For step-by-step instructions, see [Bulk reset progress for multiple students](/setting-up-course/detailed-student-report#bulk-reset-progress-for-multiple-students).

  ## Submission history for IO coding labs

  Instructors can now view the complete submission history for IO coding labs, including execution results, performance metrics, and test case outcomes. The submissions history can be accessed via the lab management interface, making it easy to monitor class progress and identify common issues. The submissions history table displays comprehensive information about each code submission, including date, status, language, runtime, memory usage, and test case results. This feature helps instructors track student progress, recognize patterns, and support effective learning.

  To access submission history, navigate to **Coding Labs → IO Labs → open any lab → Try out lab**, then click on **Submission history**.

  For more information, see [Submissions History](/creating-io-coding-labs/submissions).

  ## Resources in course syllabus

  You can now add downloadable resources and materials directly to your course syllabus, allowing students to access PDFs, documents, code files, templates, or any other downloadable content that supports their learning. Resources can be added as course items within sections, making it easy to provide supplementary materials alongside videos, quizzes, and other content.

  To add resources to your course, expand the course items view and select **Resources**. You can then upload files, set titles and labels, and publish the resource to make it available to students.

  For step-by-step instructions on adding resources to your course syllabus, see [Resources](/setting-up-course/syllabus/resources).

  ## Fermion sandbox

  We've introduced **Fermion sandbox**, a secure, isolated cloud sandbox for executing code safely. Sandboxes run inside fully isolated Linux containers with their own filesystem, process space, and network layer, ensuring total separation from the host system.

  **Key features:**

  * Launch, execute, and destroy sandboxes on demand
  * Real-time streaming of `stdout` and `stderr` through WebSockets
  * TypeScript and Python SDKs for easy integration

  Whether you're building a browser-based IDE, or a real-time code evaluation platform, Fermion Sandbox makes it seamless and safe. Fermion manages all infrastructure automatically, allowing developers to focus on writing and executing code.

  For more information and getting started guides, see [Fermion Sandbox](/coding-sandbox/introduction).

  ## Enhanced assignment grading with file uploads

  Assignment grading has been enhanced with the ability to upload files when providing grades and feedback to students. Instructors can now upload evaluated copies of submitted assignments (such as annotated PDFs), along with grades and remarks, providing richer feedback to learners.

  Students can view these uploaded files directly in their course, allowing them to see detailed annotations, corrections, and comments on their submissions. This feature enhances the feedback process by making it more visual and comprehensive, helping students better understand their work and areas for improvement.

  To learn more about reviewing and grading assignments, see [Assignments](/setting-up-course/assignments#review--grade-assignment-submissions).

  ## Instructor management API endpoints

  You can now manage instructors programmatically through Fermion's API. Two new endpoints allow you to create and remove instructor accounts for your school:

  * **[Create instructor account](/api-reference/user/create-instructor-account)**: Create a new instructor account for your school. This function is idempotent, calling it multiple times with the same email will not create duplicate accounts. If the instructor already exists, they will be added to your school if not already associated.

  * **[Remove fermion instructor from school](/api-reference/user/remove-fermion-instructor-from-school)**: Revoke an instructor's access to your school programmatically. This endpoint allows you to remove instructors from your school via API calls, making it easier to manage instructor access at scale.
</Update>

<Update label="October 2025">
  ## Add tags to course items

  You can now add and manage tags for your course items, making it easy for learners to filter content by topic, difficulty, or custom labels. Tags help you organize your course syllabus and allow students to quickly find relevant lectures, quizzes, or assignments

  For example, you might tag lessons as “Easy”, “Medium”, or “Hard”, or organize content by topics like “Frontend”, “Backend”, or “Databases”.

  [Learn how to add and use tags in your course items](/setting-up-course/tags#adding-and-using-tags-in-course-items).

  ## Maximum watch time constraint

  Set a time limit for watching recorded videos with the Maximum Watch Time Constraint. Once playback starts, learners must finish within the set period or lose access. [Learn more.](/setting-up-course/syllabus#maximum-watch-time-constraint)

  ## Whatsapp marketing

  Easily reach and engage your learners with **Whatsapp marketing** campaigns! Instructors and admins can now send announcements, reminders, and promotional messages directly to students’ Whatsapp inboxes.

  Check out our step-by-step guide to setup [WhatsApp marketing](/marketing-tools/whatsapp-marketing).

  ## Whiteboard during live streams

  Instructors can now use an interactive **whiteboard** during live streams to enhance engagement and clarify complex concepts. Draw, write, and annotate in real-time while teaching, making it easier to explain ideas visually to all participants.

  **Key features:**

  * Access the whiteboard directly from the live session toolbar.
  * Draw freehand, add shapes, write text, and use erasers for quick edits.
  * Share your whiteboard with all participants for collaborative learning.

  For more details, see [Whiteboard during live streams](/live-classes/whiteboard).

  ## 1:1 calls

  Instructors can now initiate and manage **1:1 calls** directly with students for personalized mentoring. This feature enables one-on-one communication outside of group live sessions.

  To set up 1:1 calls, navigate to **Instructor Dashboard → Live → 1:1 Calls** .

  For more information, please refer to [1:1 Calls](/live-classes/one-one-calls).

  ## Share system audio during live streams

  You can now share your system audio while presenting in a live class. This allows you to broadcast audio from videos, music, or any application on your computer directly to all participants. When you click **Share screen** in a live session, select a window or tab and enable the **Share system audio** option. This is especially useful for sharing video clips or any content where audio is important. For more details, see [Sharing system audio](/live-classes/invite-to-stage#sharing-system-audio).

  ## Event calendar

  The **Event Calendar** brings all your live sessions and events together in one place, making it easy to plan, schedule, and manage live classes. You can view all upcoming sessions, check for overlaps, and make quick adjustments directly from your dashboard.

  **Key features:**

  * Access the Event Calendar from the instructor dashboard under the **Live** section.
  * Schedule individual live sessions by clicking on a date and filling in session details.
  * Bulk schedule multiple sessions at once by uploading a CSV file with session information.
  * Download a sample CSV from the Bulk Schedule interface to ensure correct formatting.
  * Each session can include details like course, section, title, start time, duration, and co-hosts.

  For more details, see [Event Calendar](/live-classes/event-calendar).

  ## Custom checkout fields

  You can now collect additional information from learners during checkout using **Custom Checkout Fields**. Add text inputs or dropdowns to your course checkout forms, configure required fields, and export responses with sales data or access them via webhooks. Please refer to [Custom Checkout Fields](/setup-pricing/checkout-fields) for more information.

  ## Custom links in user dashboard.

  Instructors can now add **custom links** to the User Dashboard sidebar.

  * Configure them under **Settings → User Dashboard → Sidebar Custom Links**.
  * Each link requires a **label** (sidebar text) and a **URL** (destination).
  * For more information, please refer to [Custom Links](/manage-settings/custom-links)
</Update>

<Update label="September 2025">
  ## Video transcripts

  Instructors can now opt-in to have both their live sessions and recorded videos transcribed. Captions are natively generated in the same audio language that is being used in the video / live session.
  This option can be enabled for your entire school from :

  * For recorded videos: Settings → School settings → Recorded video settings
  * For Live sessions: Settings → School settings → Livestreaming settings
    For more information, refer to: [Live transcripts](/live-classes/recording-and-captions) & [Recorded video transcripts](/recorded-videos/captions)

  Additionally, this option can also be toggled on a per-stream and per-video basis directly from the session manager and video settings respectively.

  Fermion Pro members have 5 hours of transcription included in their plan. Any additional transcriptions are charged at 0.3\$/hour.
  Please refer to [Fermion Pricing](https://fermion.app/pricing).

  ## Forms v2

  We've completely revamped forms on the platform allowing organizations to build multi‑step forms that can capture detailed information from users, feedback and much more. You can also share forms as public links outside of your organization, customize fields, require answers, add descriptions and cover images, then publish when ready. For more information, please refer to: [Forms](/forms/introduction)

  ## Livestreaming updates

  Instructors can pin a tile for everyone so all students stay focused on the same view: [Pin a tile](/live-classes/pin-a-tile)
  Instructors now have an option where they can automatically add everyone to the stage (Ideal for smaller live sessions with less than 50 participants) , which will allow seamless communication between a small group of people: [Stage](/live-classes/invite-to-stage)

  ## Authentication API endpoint

  Creates a login link for a user to log in directly to your Fermion‑managed LMS. Useful when you have your own system and want seamless SSO‑like access

  ### Why this is useful

  * Seamless hand‑off from your existing app/portal: generate a link server‑side and redirect users into the LMS without an extra login step.
  * Passwordless onboarding: include the link in welcome emails/SMS to let invited users jump straight into their course.
  * Post‑purchase experience: after checkout on your site, deep‑link users directly into the relevant product area in the LMS.
  * Legacy migrations: move users from another system and let them access content before setting/resetting a Fermion password.
  * Mobile apps: open the link from your mobile client to bootstrap a signed‑in web session
    For more information, please refer to:[API Docs](/api-reference/user/get-login-link-for-user)

  ## Email & Analytics

  Added an email logs dashboard so instructors can access all emails sent out from their School.

  You can access this from the Settings → School Settings option in your sidebar: [email log](/manage-settings/email-log)

  ## Livestreaming

  New configuration to hide the seekbar in livestreams , allowing students to always be watching the stream live in real-time without the ability to seek the video. Instructors can toggle this option from **Settings → School Settings**.

  ## Video watermarking

  Added customization options for watermarking, allowing instructors to manually customize the size , style and data displayed in the watermark. Instructors can customize this from **Settings → School Settings**.
  For more information, please refer to :[Video Watermarking](/recorded-videos/introduction#video-watermarking)

  ## Courses & syllabus

  Enhanced bulk syllabus import: You can now import entire course syllabi directly from CSV files, making it easier to migrate or update course structures at scale. The import process now supports improved error handling, field mapping, and validation for a smoother experience. For step-by-step instructions, see [Bulk import syllabus](/setting-up-course/bulk-import-syllabus).

  ## AI Features

  Livestream statistics are now AI-powered, offering more intelligent insights and analytics for live sessions. Additionally, instructors can now view post-livestream feedback to better understand student engagement and improve future sessions.
</Update>

<Update label="August 2025">
  ## Platform UI/UX

  The instructor dashboard has been completely revamped with a modern interface that improves navigation and usability.

  The All Users page has been reworked with better filtering and management capabilities. Course landing pages now have an updated UI that's more engaging for potential students.
  You can see this revamped all users page from **Dashboard → Users → All users**.

  ## Content Management

  Public tags are now supported across the platform, enabling instructors and students to categorize and search content more efficiently. Tags can be added to all digital products on Fermion, making it easier to filter and explore relevant materials. This enhancement improves content organization, helps users find topics of interest faster, and supports better content curation for both public and private resources.

  The quiz import process has been improved with optional question answer explanation fields. You can check [Quiz](/setting-up-course/syllabus#what-is-a-quiz%3F) for more information.
</Update>

<Update label="July 2025" description="Major platform enhancements">
  ## Labs

  MySQL 8 support has been added for IO labs, providing better performance and compatibility with modern database systems. Please refer to [SQL Labs](/creating-io-coding-labs/sql-lab) for more information.

  ## Course Management

  * We've introduced course announcements, allowing instructors to communicate important updates directly within courses. You can send an announcement from **Course builder -> Announcements -> Create a new announcement**.

  * The syllabus manager now supports subsections, allowing instructors to break down modules into multiple levels for improved organization and clarity in complex course structures. This makes it easier to create, edit, and navigate detailed syllabi, especially for courses with nested topics or multi-part lessons or batches.

  * Admin controls for ebooks have been expanded, enabling more granular management of ebook access, permissions, and distribution. Instructors can now assign ebooks to specific users or groups, set expiration dates, and monitor usage analytics directly from the dashboard. Please refer to [Ebooks](digital-products/landing-page) for more information.

  * Item bundles are now supported, letting instructors group related course items—such as videos, quizzes, assignments, and ebooks—into cohesive bundles. Bundles can be used to create themed learning paths, offer package deals, or simplify content management for both instructors and students.

  ## Analytics & Reporting

  Livestream analytics have been completely reworked with more detailed insights and better reporting capabilities. WebRTC and SDK now support livestream ended events for better session tracking. A new UTM marketing reporting page has been added to help track marketing campaign effectiveness.

  ## User Management & Security

  User import functionality has been significantly improved with password-based import support and better UI for bulk user operations. Instructors can now reorder other instructors and edit user profiles with enhanced admin capabilities. Video proctoring features have been added for better exam security.
</Update>

<Update label="June 2025" description="AI improvements and livestreaming enhancements">
  ## AI & Content Creation

  A new AI agent has been introduced for building coding labs, significantly streamlining the lab creation process. The AI builder UI inside DSA labs has been improved with better user experience and more intuitive controls.

  ## Livestreaming & Video

  Livestreaming capacity has been expanded to support up to 50 people on stage, enabling larger interactive sessions. Manifestless livestreaming has been implemented for better compatibility and performance. The video player now includes a download button on embed pages, and object storage UI has been improved for better file management.

  ## User Experience

  New permission presets have been added to simplify access control configuration. The user dashboard now displays upcoming live sessions for the day, helping students stay informed about their schedule. Email functionality has been enhanced with the ability to turn off reminder emails for better customization.

  ## Platform Improvements

  Assignment submissions now include grading capabilities, and a dedicated page has been added to view all assignment submissions. Contest proctoring has been improved for better exam security, and the system now supports discount billing cycles for more flexible pricing options.
</Update>

<Update label="May 2025" description="Storage, payments, and video enhancements">
  ## Storage & File Management

  The Fermion Object Store now supports uploading any file type, providing more flexibility for content creators. Bulk video deletion capabilities have been added, making it easier to manage large video libraries. Object storage UI has been improved for better user experience and file management.

  ## Payments & Authentication

  Registration with phone numbers is now supported, expanding authentication options for users. Custom Razorpay integration has been implemented with public key exposure from the backend for enhanced payment processing. Terms of Service and Privacy Policy support has been added for better legal compliance.

  ## Course Management & Assignments

  Assignment submission flow has been implemented with support for Python indentation in coding assignments. Course items can now have discussions toggled on or off, and items in recorded courses can be individually toggled for better content control. Course creation dates can now be modified for better course management.

  ## Video & DRM

  DRM controls are now enabled on video embed pages for better content protection. Video playback no longer requires user authentication tokens for DRM content, improving user experience.

  ## Live Events

  External hosts can now be invited to live events, expanding collaboration possibilities. You can refer to [Add external hosts](/live-classes/setup-live-class#session-configuration) for more infrmation.
</Update>

<Update label="April 2025" description="QnA, certificates, and streaming improvements">
  ## Course Content & QnA

  QnA functionality has been added for video and article course items, enabling students to ask questions and receive answers directly within the content. Pre-recorded videos can now be downloaded for offline viewing.

  ## Live Streaming & Attendance

  Live sessions now feature robust DRM (Digital Rights Management) support through our API, providing advanced content protection for both scheduled and on-demand streams. This ensures that only authorized users can access live educational content, helping institutions and instructors safeguard their intellectual property. For technical details and integration steps, see [API - Live session DRM](/api-reference/live/create-live-session).

  Attendance tracking capabilities have been expanded to include non-Fermion live sessions, enabling instructors to monitor and record participant engagement in external webinars, workshops, or third-party events. Attendance data can be exported and analyzed alongside internal session metrics for comprehensive reporting.

  ## Certificates & Reports

  Custom HTML certificate support has been added with CBC (Course-Based Certificate) functionality. Certificate regeneration capabilities have been implemented for better certificate management. Please refer to: [Certificates](setting-up-course\completion-certificate) for more information.

  ## AI & Infrastructure

  AI builder functionality has been enabled on the coding lab page, making it easier to create interactive programming exercises. The syllabus page now features new AI capabilities for content creation and management.

  ## Platform Features

  * [SCORM](/setting-up-course/syllabus#what-are-scorm-packages%3F) package support has been introduced, allowing instructors to import and deliver standardized e-learning content directly within courses. This enables seamless integration with external LMS platforms, supports interactive learning modules, and ensures compatibility with a wide range of educational resources.
  * The "Go Live" button is now available inside courses for easier live session initiation. Please refer to [Set up a live class](https://docs.fermion.app/live-classes/setup-live-class) for more information.
</Update>

<Update label="March 2025" description="Billing, reviews, and content features">
  ## Billing & Financial Management

  A comprehensive refunds UI has been added to the platform, making it easier to manage refunds and financial transactions. Instructor billing pages have been implemented, providing better financial oversight.

  ## Reviews & Instructor Tools

  Course reviews are now visible to instructors, providing valuable feedback for course improvement. Product ratings functionality has been added, allowing students to rate courses and content. Bundles can now be locked based on the order of courses, providing better content sequencing control.

  ## Course Content & Contests

  In-video quiz functionality has been added, allowing quizzes to be embedded directly within video content. Free previews are now supported for both coding labs and videos. Contest management has been enhanced with dedicated student pages, export capabilities, and improved navigation. Contests are now displayed on the user dashboard for better visibility.

  ## User Experience & Marketing

  * Email marketing campaigns can now be cloned, allowing you to quickly duplicate successful campaigns and iterate on messaging. Campaigns can also be tested before sending, making it easier to optimize content and delivery for your audience.
  * The platform now supports [embedding ebooks](digital-products/embed-ebook) directly within course content, enabling richer learning experiences and seamless access to supplementary materials. Ebook analytics are available to track engagement and reading progress.
</Update>

<Update label="February 2025" description="Video management and lab enhancements">
  ## Video Management & Import

  Bulk video importing capabilities have been added, allowing instructors to upload multiple videos at once for more efficient content management. Video constraints have been implemented for better content control and security.

  ## Coding Labs & Integration

  IO labs can now be embedded in external websites, expanding the reach of interactive programming exercises: [Embed coding labs](/creating-coding-labs/embedding-lab)

  ## Course Management

  Course cloning functionality has been added, making it easier to duplicate successful course structures. Custom section names can now be added in CBC (Course-Based Certificates) for better organization.

  ## Contests & Proctoring

  Contest functionality has been enhanced with basic proctoring layers for better exam security. Copy-paste constraints have been added to prevent cheating during contests. Contest attempts can now require course resets on failure for better learning outcomes.

  ## Forms & Community

  Forms now include the .fermion-form class for better styling integration. Blog functionality has been enhanced with category support for better content organization. Public channels can now be viewed anonymously, expanding community access.

  ## User Management & Analytics

  User import functionality has been improved with better UI and the ability to remove users from products. User deletion capabilities have been added for better account management. Analytics have been enhanced with more data points in user activity tracking.
</Update>

<Update label="January 2025" description="Live streaming v2 and platform foundations">
  ## Live Streaming v2

  All live sessions now run on the new Live v2 infrastructure, providing significantly improved stability and performance. The system includes better reconnection capabilities, encoding optimizations, and bitrate controls for enhanced streaming quality. Public APIs have been added to start and end streams programmatically, and live session recordings can now be downloaded for offline access.

  ## DRM & Security

  Live sessions now include advanced DRM features, making it harder to capture or share streams outside the platform. Recorded videos benefit from both DRM and optimized playback speeds, providing a smoother viewing experience while maintaining security. For details on how DRM works for live sessions and how to enable it, see: [DRM for live sessions](/live-classes/drm-and-watermarking)

  ## Certificates & Recognition

  Comprehensive certificate support has been added across the platform with generator fixes and improved functionality. Certificates can now be generated for various completion milestones, providing better student recognition and motivation: [Completion certificates](\setting-up-course\completion-certificate)

  ## Contests

  Contest functionality is now available, allowing instructors to create, manage, and monitor contests directly within the platform. Detailed reporting tools provide insights into participant performance, submission analytics, and overall contest outcomes. Attempt tracking enables both students and instructors to review progress, monitor multiple attempts, and identify areas for improvement.

  ## Live events

  Live event invites can now be sent to participants, streamlining event organization and ensuring attendees receive timely notifications and reminders. This makes it easier to coordinate live sessions, workshops, and webinars.

  All live event sessions are now automatically post-processed after completion. This includes enhancements to recording quality, improved accessibility features such as captions and transcripts, and faster availability of session replays for students who could not attend live.

  ## Community

  Public channels are now accessible to all users, including those not logged in, which broadens community engagement and allows prospective students to explore discussions and resources before joining. This feature helps foster a more open and active learning community. Please refer to [Communities](/community/what-are-communities) for more information.
</Update>

<Update label="December 2024" description="Content management and platform enhancements">
  ## Downloadable Products Support

  Fermion now supports downloadable products as a standalone content type, allowing instructors to sell and distribute digital resources such as PDFs, templates, software, and other downloadable materials. This feature includes secure download links, access control, and delivery management, expanding monetization options beyond traditional courses and eBooks.

  ## Enhanced Configuration Management

  The `enabledFeatures` property has been added to the platform configuration system, providing administrators with granular control over which features are available to their institution. This enhancement allows for better customization of the platform experience and enables institutions to tailor Fermion to their specific needs and requirements.

  ## Bulk Syllabus Import Enhancement

  The bulk syllabus import functionality has been significantly improved, allowing instructors to efficiently import entire course structures from CSV files. This feature supports complex course hierarchies, multiple content types, and automated validation, making it easier to migrate existing courses or create new ones at scale.

  ## Blog System Integration

  A comprehensive blog system has been integrated into Fermion, enabling instructors and institutions to create and manage blog content directly within the platform. This feature supports content creation, publishing workflows, and SEO optimization, helping institutions build their online presence and engage with their audience through regular content updates.

  ## Instructor Invoice Breakdown

  Instructors now have access to detailed upcoming invoice breakdowns, providing clear visibility into expected payments, commission structures, and financial projections. This enhancement helps instructors better understand their revenue streams and plan their business activities accordingly.

  ## User Import Capabilities

  Advanced user import functionality has been implemented, allowing administrators to bulk import users with detailed profile information, enrollment data, and permission settings. This feature supports various import formats and includes validation to ensure data integrity during the import process.

  ## Live Class General Availability

  Live class functionality has been made generally available across all platform tiers, removing previous limitations and making this powerful feature accessible to all instructors. This change democratizes live teaching capabilities and enables more institutions to deliver real-time educational experiences.

  ## Coding Labs as Separate Items

  Coding labs can now be created and sold as standalone products, independent of traditional courses. This enhancement allows instructors to monetize individual programming exercises and assessments, providing more flexible content delivery options and enabling students to purchase specific technical skills training.

  ## User Progress Reset Functionality

  Administrators and instructors now have the ability to reset user progress for specific courses or activities, enabling better course management and allowing students to retake content when needed. This feature includes audit trails and confirmation processes to ensure proper usage.

  ## Tags System Implementation

  A comprehensive tagging system has been implemented across the platform, allowing for better content organization, searchability, and categorization. Tags can be applied to courses, labs, articles, and other content types, making it easier for students to discover relevant materials and for instructors to organize their content libraries.

  ## Enhanced Sales Manager Filters

  The sales manager interface has been enhanced with advanced filtering capabilities, allowing administrators to analyze sales data by various criteria including date ranges, product types, payment methods, and customer segments. These filters enable more detailed business intelligence and help optimize sales strategies.
</Update>

<Update label="November 2024" description="Product updates">
  ## Streamline your URL management with custom redirects

  `Custom redirects` give you complete control over URL redirections within your platform so you can easily maintain and manage URL structures.

  You can:

  * Create exact path matches for precise URL control or create wildcard matches.
  * Set up static pathname or URL redirects
  * Manage multiple redirects from a central dashboard
  * Instant publishing and unpublishing capabilities

  Custom redirects are particularly useful for updating URLs while maintaining existing links, creating shorter paths to specific pages, and managing seasonal or temporary redirects, all while ensuring seamless navigation after content restructuring.

  You can read more about setting up custom redirects in our documentation: [Custom redirects](/custom-landing-pages/custom-redirects).

  ***

  ## Add free previews to your course

  Your online courses can now support free previews on specific course items for your students. `Free preview` means that users will be able to access the item without purchasing or logging into the platform.

  You can enable or disable free previews for `articles` inside your course items. Learn more about enabling free previews in the documentation.

  ***

  ## Gamify the learning experience for your students

  You can now manage and customize how gamification should work on your platform. Head over to `Gamification` tab from your Fermion dashboard, where you can control various toolings including:

  * Enabling custom XP rewards on various actions (completing a coding lab, watching a video, finishing a quiz, etc).
  * Adding negative XP to discourage users from performing certain actions, for example: downloading solutions inside a coding lab.
  * Enabling custom XP rewards for students, as a part of "daily attendance" on the platform as well as live classes.
  * Configuring XP rewards for `platform streaks`.

  To set up gamification controls for your school, read \[our documentation].

  ***

  ## Introducing affiliate marketing tooling for your online school

  Fermion allows you to configure a powerful affiliate marketing system for your online academy, with its built-in affiliate marketing tooling. You can enable affiliate program for your students, create custom affiliate links, monitor your affiliates, and optimize in real-time.

  All affiliate payouts are handled by Fermion making it easier for you to focus and scale your teaching business. These features are available to instructors on all plans. Check out [Affiliate marketing](/marketing-tools/affiliate-marketing) to learn more.
</Update>

<Update label="October 2024" description="AI labs, infrastructure, and business features">
  ## AI-Generated Labs Support

  Fermion now supports AI-generated labs for GoLand and Node-Vitest environments, making it easier for instructors to create interactive programming exercises. This feature leverages artificial intelligence to automatically generate coding challenges, test cases, and starter code, significantly reducing the time needed to create high-quality lab content. The AI assistance helps instructors focus on teaching rather than spending hours crafting technical exercises.

  ## Infrastructure Migration

  Playgrounds have been successfully migrated to Google Cloud Platform (GCP), providing better performance, scalability, and reliability for all interactive coding environments. This migration ensures faster load times, improved stability during peak usage, and enhanced security for all lab activities across the platform.

  ## Forms Functionality

  A comprehensive forms system has been implemented, allowing instructors to create custom forms for data collection, feedback gathering, and student onboarding. Forms can be embedded throughout the platform and integrated with the student management system for seamless data collection and organization.

  ## Payment System Enhancements

  Support for PaySharp UPI has been added, expanding payment options for Indian users with faster transaction processing and lower fees. The platform now features a unified invoice management system where all invoices are accessible from a single page, making financial tracking and management more efficient for instructors and administrators.

  ## eBook Sales Capability

  Instructors can now sell eBooks as standalone digital products, expanding content monetization options beyond traditional courses. This feature includes dedicated landing pages, payment integration, and delivery systems specifically designed for digital book sales.

  ## Pricing and Business Updates

  Updated pricing plans provide better value and clearer options for different types of educational institutions. Partial payment plan support has been implemented, allowing students to pay for courses in installments, making education more accessible. Enterprise pricing support has been added for larger institutions requiring custom solutions and dedicated support.

  ## Live Class Calculator

  A live class calculator has been added to the pricing page, helping instructors understand the costs and benefits of different live class configurations. This tool assists in planning and budgeting for live educational sessions.
</Update>

<Update label="September 2024" description="User tools and authentication improvements">
  ## User Query Tool

  A powerful user query tool has been introduced for Fermion administrators, enabling advanced search and filtering capabilities across all user data. This tool allows administrators to quickly find specific users, analyze user behavior patterns, and generate detailed reports for better platform management and user support.

  ## Instructor Dashboard v1

  The first version of the instructor dashboard has been launched, providing a centralized hub for all instructor activities. This dashboard offers quick access to course management, student analytics, live session controls, and platform settings, streamlining the teaching workflow and improving user experience.

  ## Google Login Integration

  Google authentication has been integrated into the platform, allowing users to sign in using their Google accounts. This feature simplifies the onboarding process for new users and provides a familiar, secure authentication method that reduces friction during account creation and login.

  ## Livestreaming Statistics

  A comprehensive livestreaming stats page has been implemented, providing detailed analytics for live sessions including attendance rates, engagement metrics, chat activity, and technical performance data. These insights help instructors optimize their live teaching strategies and identify areas for improvement.

  ## Invoice System Improvements

  The invoice system has been significantly enhanced with improved formatting, better organization, and service invoice capabilities. These improvements make it easier for instructors to manage billing, track payments, and provide professional documentation to students and organizations.

  ## New School Ledger Infrastructure

  A new school ledger infrastructure has been implemented to better track financial transactions, manage multiple payment methods, and provide detailed financial reporting. This system supports complex billing scenarios and provides better visibility into school finances.

  ## Additional School Management Flags

  New configuration flags have been added for school management, providing administrators with more granular control over platform features, user permissions, and system behavior. These flags enable customization of the platform to meet specific institutional needs and requirements.
</Update>

<Update label="August 2024" description="Analytics and reporting enhancements">
  ## Custom Analytics Dashboard

  A comprehensive custom analytics dashboard has been implemented, providing instructors with detailed insights into student engagement, course performance, and platform usage. This dashboard features customizable widgets, real-time data updates, and exportable reports for deeper analysis.

  ## Advanced Analytics Reports

  Enhanced analytics reporting capabilities now include detailed breakdowns of student progress, content engagement metrics, and performance analytics across different course types. These reports help instructors identify successful teaching strategies and areas that need improvement.

  ## Analytics Export and Import

  The platform now supports exporting analytics data in multiple formats for external analysis and importing historical data for comprehensive reporting. This feature enables integration with external business intelligence tools and supports detailed data analysis workflows.

  ## Analytics Visualization Tools

  Advanced visualization tools have been added to the analytics system, including interactive charts, graphs, and tables that make complex data more accessible and understandable. These visualizations help instructors quickly identify trends and patterns in student behavior and course performance.

  ## Analytics Filtering and Search

  Powerful filtering and search capabilities have been implemented for analytics data, allowing instructors to focus on specific time periods, student segments, or course components. This functionality enables targeted analysis and helps instructors make data-driven decisions about their teaching strategies.
</Update>

<Update label="July 2024" description="Admin management and platform control">
  ## Custom Admin Dashboard

  A comprehensive admin dashboard has been implemented, providing administrators with centralized control over all platform functions. This dashboard includes user management, course oversight, payment monitoring, and system configuration tools, enabling efficient platform administration.

  ## Admin Profile Management

  Enhanced admin profile management capabilities allow administrators to maintain detailed profiles with role-based access controls and activity tracking. This system ensures proper accountability and provides clear audit trails for administrative actions.

  ## Admin Settings Configuration

  Advanced admin settings configuration options have been added, enabling fine-tuned control over platform behavior, user permissions, and system features. These settings allow administrators to customize the platform to meet specific institutional requirements and policies.

  ## Admin Course Management

  Comprehensive course management tools for administrators include bulk course operations, content moderation, and instructor assignment capabilities. These tools enable efficient oversight of all educational content and ensure quality control across the platform.

  ## Admin Student Management

  Advanced student management features for administrators include bulk user operations, enrollment management, and academic progress tracking. These capabilities support large-scale educational operations and provide administrators with complete visibility into student activities.

  ## Admin Instructor Management

  Dedicated instructor management tools allow administrators to oversee instructor activities, manage permissions, and monitor teaching performance. This system ensures quality control and provides support for instructor development and evaluation.

  ## Admin Payment Oversight

  Comprehensive payment oversight tools provide administrators with detailed visibility into all financial transactions, payment processing, and revenue management. These tools support financial planning and ensure proper accounting practices.

  ## Admin Invoice Management

  Advanced invoice management capabilities include bulk invoice operations, payment tracking, and financial reporting tools. This system streamlines financial administration and provides detailed records for accounting and auditing purposes.

  ## Admin Receipt Management

  Enhanced receipt management features allow administrators to generate, track, and manage payment receipts across the platform. This system ensures proper financial documentation and supports customer service operations.

  ## Admin Analytics Dashboard

  A dedicated analytics dashboard for administrators provides institution-wide insights into platform usage, student engagement, and educational outcomes. This dashboard supports strategic decision-making and helps administrators optimize platform performance.
</Update>

<Update label="June 2024" description="Instructor management and teaching tools">
  ## Custom Instructor Dashboard

  A dedicated instructor dashboard has been implemented, providing instructors with a centralized hub for all teaching activities. This dashboard includes course management tools, student communication features, and performance analytics, streamlining the teaching workflow.

  ## Instructor Profile Management

  Enhanced instructor profile management allows instructors to maintain detailed professional profiles with teaching credentials, specializations, and portfolio information. This system helps students understand instructor backgrounds and expertise.

  ## Instructor Settings Configuration

  Advanced instructor settings enable customization of teaching preferences, notification preferences, and platform behavior. These settings allow instructors to tailor the platform to their teaching style and workflow requirements.

  ## Instructor Course Management

  Comprehensive course management tools for instructors include content creation, syllabus organization, and student progress tracking. These tools support effective course delivery and help instructors manage multiple courses efficiently.

  ## Instructor Student Management

  Dedicated student management features allow instructors to track student progress, communicate with learners, and provide personalized support. These capabilities enable instructors to maintain close relationships with their students and identify those who need additional help.

  ## Instructor Payment Tracking

  Payment tracking tools for instructors provide visibility into course revenue, student payment status, and financial performance. This information helps instructors understand the business aspects of their teaching activities.

  ## Instructor Invoice Management

  Invoice management capabilities allow instructors to track billing, monitor payment status, and manage financial records related to their courses. This system supports professional financial management for instructors.

  ## Instructor Receipt Management

  Receipt management features enable instructors to generate and track payment receipts for students, ensuring proper financial documentation and supporting customer service needs.

  ## Instructor Analytics Dashboard

  A comprehensive analytics dashboard for instructors provides insights into student engagement, course performance, and teaching effectiveness. This dashboard helps instructors optimize their teaching strategies and improve student outcomes.

  ## Advanced Instructor Settings

  Enhanced instructor settings provide additional customization options for teaching preferences, platform behavior, and integration with external tools. These settings enable instructors to create personalized teaching environments.
</Update>

<Update label="May 2024" description="Student experience and management">
  ## Custom Student Dashboard

  A personalized student dashboard has been implemented, providing learners with a centralized hub for all their educational activities. This dashboard includes course progress tracking, upcoming assignments, live session schedules, and achievement tracking.

  ## Student Profile Management

  Enhanced student profile management allows learners to maintain detailed profiles with academic information, learning preferences, and progress tracking. This system supports personalized learning experiences and helps instructors understand individual student needs.

  ## Student Settings Configuration

  Advanced student settings enable learners to customize their learning experience, including notification preferences, display options, and accessibility features. These settings ensure the platform adapts to individual learning styles and requirements.

  ## Student Enrollment Management

  Streamlined enrollment management allows students to easily enroll in courses, track enrollment status, and manage multiple course enrollments. This system simplifies the learning journey and reduces administrative friction.

  ## Student Progress Tracking

  Comprehensive progress tracking provides students with detailed insights into their learning journey, including completion rates, time spent on activities, and performance metrics. This information helps students stay motivated and identify areas for improvement.

  ## Student Completion Management

  Enhanced completion management tracks student achievements, certificate eligibility, and course completion status. This system ensures proper recognition of student accomplishments and supports credential management.

  ## Student Certificate System

  A comprehensive certificate system has been implemented, allowing students to earn and manage completion certificates for their courses. This system includes verification capabilities and sharing options for professional development.

  ## Student Payment Management

  Student payment management tools provide learners with visibility into their payment status, billing history, and financial obligations. This system supports transparent financial management and helps students understand their investment in education.

  ## Student Invoice Access

  Students now have access to their invoices and billing information through the platform, enabling self-service financial management and reducing support requests related to billing inquiries.

  ## Student Receipt Management

  Receipt management capabilities allow students to access and download payment receipts, supporting expense tracking and financial record-keeping for tax and reimbursement purposes.
</Update>

<Update label="April 2024" description="Course customization and certification">
  ## Custom Course Pages

  Enhanced course page customization allows instructors to create unique, branded course experiences that reflect their teaching style and institutional identity. These custom pages support various layouts, color schemes, and content organization strategies.

  ## Custom Course List Pages

  Instructors can now customize course listing pages to showcase their offerings in the most effective way. This includes custom filtering options, sorting capabilities, and presentation formats that help students find relevant courses quickly.

  ## Custom Course Detail Pages

  Detailed course pages can be fully customized to provide comprehensive information about course content, instructor credentials, learning outcomes, and enrollment requirements. This customization helps students make informed decisions about their educational investments.

  ## Custom Course Enrollment Pages

  Streamlined enrollment pages can be customized to match institutional branding and provide clear enrollment processes. These pages support various enrollment scenarios and help reduce abandonment rates during the registration process.

  ## Custom Course Completion Pages

  Completion pages can be customized to celebrate student achievements and provide next steps for continued learning. These pages support various completion scenarios and help maintain student engagement beyond course completion.

  ## Custom Course Certificates

  A comprehensive certificate system has been implemented, allowing instructors to create custom certificates that reflect their brand and institutional identity. These certificates can include custom designs, verification codes, and professional formatting.

  ## Custom Certificate Templates

  Multiple certificate templates are available for different types of courses and achievements. Instructors can choose from various designs or create completely custom templates that align with their brand and educational goals.

  ## Certificate Download System

  Students can easily download their certificates in multiple formats, including PDF and image files. The download system includes verification features and ensures certificates are properly formatted for professional use.

  ## Certificate Verification System

  A robust certificate verification system allows third parties to verify the authenticity of student certificates. This system includes unique verification codes and online verification tools that support professional credential validation.

  ## Certificate Sharing Capabilities

  Enhanced certificate sharing features allow students to share their achievements on social media, professional networks, and job applications. This system supports various sharing formats and includes privacy controls for student data protection.
</Update>

<Update label="March 2024" description="Payment system customization">
  ## Custom Checkout Experience

  A fully customizable checkout experience has been implemented, allowing instructors to create branded payment flows that match their institutional identity. This customization includes custom colors, logos, and messaging that reinforce brand recognition during the payment process.

  ## Custom Checkout Pages

  Checkout pages can be completely customized to provide clear pricing information, payment options, and terms of service. These custom pages help reduce payment abandonment and provide a professional purchasing experience.

  ## Custom Checkout Forms

  Payment forms can be customized to collect additional student information, provide clear pricing breakdowns, and include promotional messaging. This customization helps optimize conversion rates and gather valuable customer data.

  ## Custom Checkout Success Pages

  Success pages can be customized to provide clear confirmation of successful payments and next steps for course access. These pages help reduce customer confusion and provide immediate value after purchase.

  ## Custom Checkout Failure Pages

  Failure pages can be customized to provide helpful guidance when payments fail, including troubleshooting tips and alternative payment methods. This customization helps recover failed transactions and improve customer satisfaction.

  ## Custom Checkout Email Notifications

  Email notifications for checkout events can be customized to match institutional branding and provide clear information about payment status and next steps. These customized emails help maintain professional communication throughout the payment process.

  ## Custom Checkout Receipts

  Payment receipts can be customized to include institutional branding, detailed transaction information, and relevant tax documentation. This customization supports professional financial management and customer service.

  ## Custom Checkout Invoices

  Invoice generation can be customized to include institutional branding, detailed line items, and professional formatting. This customization supports various billing scenarios and provides clear financial documentation.

  ## Custom Checkout Tax Handling

  Tax calculation and handling can be customized to meet various regional requirements and institutional policies. This system supports international operations and ensures compliance with local tax regulations.

  ## Custom Checkout Discount System

  A flexible discount system allows instructors to create various promotional offers, coupon codes, and special pricing arrangements. This system supports marketing campaigns and helps increase course enrollment.
</Update>

<Update label="February 2024" description="School customization and branding">
  ## Custom Domain Support

  Fermion now supports custom domain mapping, allowing educational institutions to use their own domain names for their learning platforms. This feature enables complete white-labeling and helps institutions maintain their brand identity throughout the student experience.

  ## Custom Theme Support

  Advanced theme customization allows institutions to create unique visual identities that reflect their brand values and institutional culture. This includes custom color schemes, typography, and layout options that create distinctive learning environments.

  ## Custom Logo Integration

  Institutions can now integrate their logos throughout the platform, ensuring consistent branding across all user interfaces. This customization helps reinforce institutional identity and creates a professional learning environment.

  ## Custom Favicon Support

  Custom favicon support allows institutions to display their branding even in browser tabs and bookmarks. This small but important detail helps maintain brand consistency throughout the digital learning experience.

  ## Custom CSS Styling

  Advanced CSS customization capabilities allow institutions to implement sophisticated design changes that go beyond standard theme options. This flexibility enables complete visual customization while maintaining platform functionality.

  ## Custom JavaScript Integration

  Custom JavaScript support allows institutions to implement advanced functionality, integrate with third-party tools, and create unique user experiences. This capability supports complex institutional requirements and enables seamless integration with existing systems.

  ## Custom Email Templates

  Institutions can now customize all email communications to match their branding and communication style. This includes welcome emails, course notifications, and system communications that maintain consistent institutional messaging.

  ## Custom Email Sender Configuration

  Email sender configuration allows institutions to send emails from their own domains and email addresses. This customization ensures that all communications appear to come from the institution rather than the platform provider.

  ## Custom Email Domain Setup

  Custom email domain setup enables institutions to use their own email infrastructure for platform communications. This feature supports advanced email management and ensures compliance with institutional email policies.

  ## Custom Email Signature Management

  Email signature customization allows institutions to include professional signatures, contact information, and branding in all automated emails. This customization helps maintain professional communication standards throughout the platform.
</Update>

<Update label="January 2024" description="Platform launch and foundation">
  ## Fermion Platform Launch

  Fermion officially launched as a comprehensive learning management system designed specifically for modern educational institutions. The platform combines advanced technology with user-friendly design to create an optimal environment for online education delivery.

  ## School Creation System

  The core school creation system was implemented, allowing educational institutions to set up their own branded learning environments. This system supports multiple schools on a single platform while maintaining complete separation and customization for each institution.

  ## School Settings Management

  Comprehensive school settings management was introduced, providing administrators with granular control over platform behavior, user permissions, and institutional policies. These settings enable institutions to configure the platform to meet their specific educational and administrative requirements.

  ## School Dashboard Implementation

  A centralized school dashboard was created to provide administrators with a comprehensive overview of all platform activities, including student enrollment, course performance, and financial metrics. This dashboard serves as the command center for institutional management.

  ## School Customization Framework

  A flexible customization framework was implemented, allowing institutions to personalize their learning platforms to reflect their unique identity and educational approach. This framework supports various customization levels while maintaining platform stability and performance.

  ## School Domain Mapping

  Domain mapping capabilities were introduced, enabling institutions to use their own web domains for their learning platforms. This feature supports complete white-labeling and helps institutions maintain their online presence and brand consistency.

  ## School Analytics System

  A comprehensive analytics system was implemented to provide institutions with detailed insights into student engagement, course performance, and platform usage. This system supports data-driven decision making and helps institutions optimize their educational delivery.

  ## Student Management Infrastructure

  Robust student management infrastructure was built to support large-scale educational operations. This system includes enrollment management, progress tracking, communication tools, and administrative capabilities that scale with institutional growth.

  ## Course Management System

  A comprehensive course management system was implemented, supporting various course types including recorded courses, live classes, and hybrid learning models. This system provides instructors with powerful tools for content creation, organization, and delivery.

  ## Payment Integration Framework

  A flexible payment integration framework was implemented, supporting multiple payment gateways and currencies to serve global educational markets. This system ensures secure, reliable payment processing while supporting various business models and pricing strategies.
</Update>


# Getting Started with the Fermion Sandbox
Source: https://docs.fermion.app/coding-sandbox/getting-started

Set up Fermion Sandbox and run your first secure containerized code session.

Fermion Sandbox lets you safely execute untrusted or user-generated code inside secure, containerized Linux environments. This guide walks you through installation, setup, and creating your first sandbox: from installing the SDK to running your first command inside an isolated container.

***

## Prerequisites

Before you begin, ensure that your environment meets the following requirements.

* You’ll need **Node.js 18 or higher** | **Python** runtime installed on your system, along with a package manager such as **npm**, **yarn**, **pnpm**, **bun** for Javascript runtimes or **pip** or **uv** for python runtimes.
* A valid **Fermion API key** is required for authentication, which you can obtain from your [Fermion Dashboard](/api-guide/introduction#how-to-get-your-api-key).
* Familiarity with basic **JavaScript or TypeScript** will also be helpful as you follow along with the examples in this guide.

***

## Installation

<Steps>
  <Step title="Install the Package">
    Install the package with the help of a package manager of your choice

    <CodeGroup>
      ```bash Typescript/Javascript theme={null}
      # Using npm
      npm install @fermion-app/sandbox

      # Using yarn
      yarn add @fermion-app/sandbox

      # Using bun 
      bun install @fermion-app/sandbox

      # Using pnpm
      pnpm add @fermion-app/sandbox
      ```

      ```bash Python theme={null}
      # Using pip
      pip install fermion_sandbox

      # Using pipenv
      pipenv install fermion_sandbox

      # Using uv
      uv add fermion_sandbox

      ```
    </CodeGroup>
  </Step>

  <Step title="Get Your API Key">
    Login to your Fermion instructor dashboard and head over to **School Setting** -> **API Access** to get your `FERMION_API_KEY`. Learn more on how to get your [Fermion API key](/api-guide/introduction#how-to-get-your-api-key)
  </Step>

  <Step title="Set Up Environment Variables">
    Create a .env file in your project root and add your API key:

    ```bash theme={null}
    FERMION_API_KEY=your_api_key_here
    ```

    <Warning>
      Never commit API keys to version control. Always load them via environment variables or secure secret management systems.
    </Warning>
  </Step>
</Steps>

## Creating your first Sandbox

Let’s walk through a complete example of creating, running, and cleaning up a sandbox. This example shows how to execute a Node.js script securely in the cloud.

<CodeGroup>
  ```javaScript hello.js theme={null}
  import { Sandbox } from '@fermion-app/sandbox'

  async function main() {
    // Initialize the sandbox with your API key
    const sandbox = new Sandbox({
      apiKey: process.env.FERMION_API_KEY
    })

    try {
      // Create a new container
      console.log('Creating sandbox...')
      const snippetId = await sandbox.create({
        shouldBackupFilesystem: false // Files won't persist after disconnect
      })
      console.log('Sandbox created! Snippet ID:', snippetId)

      // Run a simple command
      console.log('\nRunning node --version...')
      const nodeVersion = await sandbox.runCommand({
        cmd: 'node',
        args: ['--version']
      })
      console.log('Node version:', nodeVersion.stdout.trim())

      // Write a file
      console.log('\nWriting hello.js...')
      await sandbox.writeFile({
        path: '/home/damner/hello.js',
        content: 'console.log("Hello from Fermion Sandbox!")'
      })
      console.log('File written')

      // Execute the file (~/ works in commands, shell expands it)
      console.log('\nExecuting hello.js...')
      const output = await sandbox.runCommand({
        cmd: 'node',
        args: ['~/hello.js']
      })
      console.log('Output:', output.stdout.trim())

      // Read the file back
      console.log('\nReading hello.js...')
      const fileResponse = await sandbox.getFile('/home/damner/hello.js')
      const fileContent = await fileResponse.text()
      console.log('File contents:', fileContent)

    } catch (error) {
      console.error('Error:', error.message)
    } finally {
      // Always clean up
      console.log('\nDisconnecting...')
      await sandbox.disconnect()
      console.log('Disconnected')
    }
  }

  main()

  ```

  ```python hello.py theme={null}
  from fermion_sandbox import Sandbox
  import os

  def main():
      # Initialize the sandbox with your API key
      sandbox = Sandbox(api_key=os.getenv("FERMION_API_KEY"))

      # Create a new container
      print("Creating sandbox...")
      snippet_id = sandbox.create(should_backup_filesystem=False)  # Files won't persist after disconnect
      print(f"Sandbox created! Snippet ID: {snippet_id}")

      # Run a simple command
      print("\nRunning python3 --version...")
      python_version = sandbox.run_command(cmd="python3", args=["--version"])
      print("Python version:", python_version.stdout.strip())

      # Write a file
      print("\nWriting hello.py...")
      sandbox.write_file(path="~/hello.py", content='print("Hello from Fermion Sandbox!")')
      print("File written")

      # Execute the file
      print("\nExecuting hello.py...")
      output = sandbox.run_command(cmd="python3", args=["hello.py"])
      print("Output:", output.stdout.strip())

      # Read the file back
      print("\nReading hello.py...")
      file_response = sandbox.get_file("~/hello.py")
      file_content = file_response.text()
      print("File contents:", file_content)

      # Always clean up
      print("\nDisconnecting...")
      sandbox.disconnect()
      print("Disconnected")

  if __name__ == "__main__":
      main()

  ```
</CodeGroup>

## Expected Output

The following code snippet will create a sandbox that executes a simple node.js program. Following is the expected output:

<CodeGroup>
  ```bash Typescript output theme={null}
  Creating sandbox...
  Sandbox created! Snippet ID: abc123xyz

  Running node --version...
  Node version: v20.11.0

  Writing hello.js...
  File written

  Executing hello.js...
  Output: Hello from Fermion Sandbox!

  Reading hello.js...
  File contents: console.log("Hello from Fermion Sandbox!")

  Disconnecting...
  Disconnected

  ```

  ```bash Python output theme={null}
  Creating sandbox...
  Sandbox created! Snippet ID: abcd-python-1234k

  Running python3 --version...
  Python version: Python 3.11.6

  Writing hello.py...
  File written

  Executing hello.py...
  Output: Hello from Fermion Sandbox!

  Reading hello.py...
  File contents: print("Hello from Fermion Sandbox!")

  Disconnecting...
  Disconnected

  ```
</CodeGroup>

## Next Steps

Now that you’ve successfully run your first sandbox, you’re ready to explore more advanced concepts and integrations.

<Columns>
  <Card title="Typescript SDK" href="/coding-sandbox/methods/initialization" icon="js">
    Explore all available methods for Typescript SDK
  </Card>

  <Card title="Python SDK" href="/coding-sandbox/python-sdk/initialization" icon="python">
    Explore all available methods for Python SDK
  </Card>
</Columns>


# Fermion Sandbox
Source: https://docs.fermion.app/coding-sandbox/introduction

Secure, isolated cloud sandboxes for executing untrusted code safely.

## Secure Code Execution in Isolated Containers

Fermion Sandbox sandbox runs inside a fully isolated Linux container with its own filesystem, process space, and network layer: ensuring total separation from the host system. Developers can launch, execute, and destroy sandboxes on demand.

You can run anything from Node.js scripts to full web servers, with real-time streaming of `stdout` and `stderr` through WebSockets. Fermion manages provisioning, teardown, and optional persistence automatically, allowing developers to focus on writing and executing code rather than managing infrastructure. Whether you’re building an AI code assistant, a browser-based IDE, or a real-time code evaluation platform, Fermion Sandbox makes it seamless and safe.

### Quick Code Preview

<CodeGroup>
  ```typescript Typescript preview theme={null}
  import { Sandbox } from '@fermion-app/sandbox'

  const sandbox = new Sandbox({ apiKey: 'your-api-key' })
  await sandbox.create({ shouldBackupFilesystem: false })

  const result = await sandbox.runCommand({
  	cmd: 'node',
  	args: ['--version']
  })
  console.log(result.stdout) // v20.x.x

  await sandbox.disconnect()
  ```

  ```python Python preview theme={null}
  from fermion_sandbox import Sandbox

  # Initialize the Fermion SDK with your API key
  sandbox = Sandbox(api_key="your-api-key")

  # Create a new sandbox environment
  sandbox.create(should_backup_filesystem=False)

  # Run a simple command inside the sandbox (example: check Python version)
  result = sandbox.run_command(
      "cmd":"python3",
     	"args": ["--version"]
  )

  # Print the output from the command
  print(result.stdout)  # Expected output: Python 3.x.x

  # Disconnect and clean up the sandbox
  sandbox.disconnect()

  ```
</CodeGroup>

## Explore More

<Columns>
  <Card title="Getting Started" href="/coding-sandbox/getting-started">
    Learn how to create, run, and manage your first sandbox in minutes.
  </Card>

  <Card title="Available Methods" href="/coding-sandbox/methods/initialization">
    Explore all available methods, and configuration options.
  </Card>
</Columns>


# Get Container Details
Source: https://docs.fermion.app/coding-sandbox/methods/container-details

Retrieve container connection details including subdomain and secure access token.

The `getContainerDetails()` method provides low-level connection information for the currently active sandbox container. It returns an object containing the **container subdomain** and a **playground access token**, which are used internally to establish and manage secure communication between your client and the Fermion infrastructure.

### `getContainerDetails()`

**Description:**
Returns container connection details including subdomain and access token, or null if not connected.

**Parameters:**
None

**Returns:**

```typescript theme={null}
{
  subdomain: string
  playgroundContainerAccessToken: string
} | null
```

**Example:**

```typescript theme={null}
const details = sandbox.getContainerDetails()

if (details) {
  console.log('Subdomain:', details.subdomain)
  console.log('Token:', details.playgroundContainerAccessToken)
}
```

<Warning>
  The access token is sensitive. Do not expose it in logs or UI.
</Warning>


# Create and Spin up a new sandbox instance
Source: https://docs.fermion.app/coding-sandbox/methods/create

Provision a new Fermion Sandbox container with optional persistence or repository cloning.

The `create()` method provisions a brand-new sandbox container within Fermion’s secure cloud infrastructure. When invoked, it initializes a clean Linux environment, configures your session, and establishes a WebSocket connection for real-time communication. Depending on the options you pass, the sandbox can be either **ephemeral** (short-lived and automatically destroyed on disconnect) or **persistent** (saved for later use).

You can also clone a Git repository during provisioning, making it easy to start from existing codebases or templates. The process typically completes within a few seconds, after which the sandbox is ready to accept commands, file operations, or server executions. The method returns a unique `snippetId`, which you can store and reuse to reconnect to the same environment later.

## `create(options)`

**Description:**
Creates and provisions a new sandbox container. This process includes:

1. Creating a playground snippet
2. Starting a session
3. Waiting for container provisioning (polling with 500ms intervals)
4. Establishing WebSocket connection
5. Waiting for container server to be ready
6. Optionally cloning a git repository

**Parameters:**

| Parameter              | Type    | Required | Default   | Description                                                               |
| ---------------------- | ------- | -------- | --------- | ------------------------------------------------------------------------- |
| shouldBackupFilesystem | boolean | Yes      | -         | If true, files persist after disconnect. If false, everything is deleted. |
| gitRepoUrl             | string  | No       | undefined | GitHub/GitLab repository URL to clone on startup                          |

**Returns:**
`Promise<{ playgroundSnippetId: string }>` - Resolves with the playground snippet ID (save this to start another container with same file system later)

**Example:**

```typescript theme={null}
// Basic ephemeral sandbox
const { playgroundSnippetId } = await sandbox.create({
  shouldBackupFilesystem: false
})

// Persistent sandbox
const { playgroundSnippetId } = await sandbox.create({
  shouldBackupFilesystem: true
})
console.log('Save this ID:', playgroundSnippetId)

// With git repository
const { playgroundSnippetId } = await sandbox.create({
  shouldBackupFilesystem: true,
  gitRepoUrl: 'https://github.com/username/repo.git'
})
```

***


# Disconnect from the Sandbox instance
Source: https://docs.fermion.app/coding-sandbox/methods/disconnect

Gracefully close the WebSocket connection and clean up sandbox resources.

## disconnect()

The `disconnect()` method gracefully terminates your active sandbox session by closing the WebSocket connection and releasing all associated resources.

### `disconnect()`

**Description:**
Gracefully terminates your active sandbox.

**Parameters:**
None

**Returns:**
`Promise<void>` - Resolves when disconnection is complete

**Example:**

```typescript theme={null}
const sandbox = new Sandbox({ apiKey: 'key' })
await sandbox.create({ shouldBackupFilesystem: false })

// Do work...

// Always cleanup
await sandbox.disconnect()
```


# Expose ports from Sandbox for a public HTTPS URL
Source: https://docs.fermion.app/coding-sandbox/methods/expose-port

Expose a sandbox port publicly over HTTPS and access live web services running inside the container.

The `exposePort()` method provides a **public HTTPS URL** that maps directly to a specific port running inside your sandbox container. Fermion automatically supports ports **3000**, **1337**, and **1338**, allowing you to host web servers, APIs, or other services securely and access them from anywhere.

When you start a server inside your sandbox, using commands like `node server.js` or `npm run dev`, you can call `exposePort(port)` to instantly retrieve a URL in the format `https://{subdomain}-{port}.run-code.com`. This enables you to preview, test, and share live services running within your sandbox without any manual networking setup or tunneling.

### `exposePort(port)`

**Description:**
Returns the public HTTPS URL for a specific port in the sandbox. The sandbox automatically exposes ports 3000, 1337, and 1338 publicly.

**Parameters:**

| Parameter | Type                 | Required | Description                              |
| --------- | -------------------- | -------- | ---------------------------------------- |
| port      | 3000 \| 1337 \| 1338 | Yes      | Port number (must be one of these three) |

**Returns:**
`Promise<string>` - Public HTTPS URL (format: `https://{subdomain}-{port}.run-code.com`)

**Example:**

```typescript theme={null}
// Start a server
await sandbox.writeFile({
	path: '/home/damner/server.js',
	content: `
    const http = require('http');
    http.createServer((req, res) => {
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end('Hello from Fermion!');
    }).listen(3000, () => {
      console.log('Server running on port 3000');
    });
  `
})

// Run server in background (~/ works in commands, shell expands it)
sandbox.runStreamingCommand({
	cmd: 'node',
	args: ['~/server.js'],
	onStdout: data => console.log(data.trim())
})

// Wait a moment for server to start
await new Promise(r => setTimeout(r, 2000))

// Get public URL
const url = await sandbox.exposePort(3000)
console.log('Access your server at:', url)
// Output: https://abc123xyz-3000.run-code.com

await new Promise(r => setTimeout(r, 30000)) // Wait for 30 seconds
```


# Create a sandbox instance using Snippet Id
Source: https://docs.fermion.app/coding-sandbox/methods/from-snippet

Create a new sandbox with same file system as previous sandbox.

The `fromSnippet()` method allows you to create a new sandbox with same file system as previous sandbox using its unique snippet ID. This is useful when you’ve created a sandbox with `shouldBackupFilesystem: true` and want to resume work without losing files or progress.

## `fromSnippet(playgroundSnippetId)`

**Description:**
Creates a new sandbox with same file system as previous sandbox using its snippet ID.

**Parameters:**

| Parameter           | Type   | Required | Description                                             |
| ------------------- | ------ | -------- | ------------------------------------------------------- |
| playgroundSnippetId | string | Yes      | The snippet ID returned from a previous `create()` call |

**Returns:**
`Promise<void>` - Resolves when connection is established

**Example:**

```typescript theme={null}
// Session 1: Create persistent sandbox
const snippetId = await sandbox1.create({
  shouldBackupFilesystem: true
})
await sandbox1.writeFile({ path: '/home/damner/data.txt', content: 'saved' })
await sandbox1.disconnect()

// Session 2: Create a new sandbox with same file system as previous sandbox
const sandbox2 = new Sandbox({ apiKey: 'key' })
await sandbox2.fromSnippet(snippetId)
const file = await sandbox2.getFile('/home/damner/data.txt')
console.log(await file.text()) // 'saved'
```

***


# Retrieve files from your Sandbox instance
Source: https://docs.fermion.app/coding-sandbox/methods/get-file

Retrieve text or binary files from the sandbox filesystem as standard web Response objects.

The `getFile()` method retrieves a file from your sandbox’s filesystem and returns it as a standard **Web Response object**, allowing you to handle the data in multiple formats: text, JSON, binary, or Blob. All file paths must start with the absolute path `/home/damner` to ensure access is confined to the sandbox’s isolated workspace.

### `getFile(path)`

**Description:**
Retrieves a file from the sandbox filesystem. Returns a standard Response object that you can read as text, binary, blob, etc.

**Parameters:**

| Parameter | Type   | Required | Description                                |
| --------- | ------ | -------- | ------------------------------------------ |
| path      | string | Yes      | File path (must start with `/home/damner`) |

**Returns:**
`Promise<Response>` - Standard fetch Response object with methods:

* `.text()` - Read as string
* `.arrayBuffer()` - Read as binary
* `.blob()` - Read as Blob
* `.json()` - Parse as JSON

**Example:**

```typescript theme={null}
// Read text file
const response = await sandbox.getFile('/home/damner/script.js')
const content = await response.text()
console.log(content)
```


# Retrieve public URLs for Exposed Ports
Source: https://docs.fermion.app/coding-sandbox/methods/get-public-urls

Retrieve all public HTTPS URLs for exposed sandbox ports (3000, 1337, 1338).

The `getPublicUrls()` method returns all available **public HTTPS endpoints** for your sandbox container in a single object. By default, Fermion automatically exposes ports **3000**, **1337**, and **1338**, each corresponding to its own unique public URL.

### `getPublicUrls()`

**Description:**
Returns all available public URLs for the sandbox (ports 3000, 1337, 1338).

**Parameters:**
None

**Returns:**

```typescript theme={null}
{
  3000: string  // https://{subdomain}-3000.run-code.com
  1337: string  // https://{subdomain}-1337.run-code.com
  1338: string  // https://{subdomain}-1338.run-code.com
}
```

**Example:**

```typescript theme={null}
const urls = sandbox.getPublicUrls()

console.log('Available URLs:')
console.log('Port 3000:', urls[3000])
console.log('Port 1337:', urls[1337])
console.log('Port 1338:', urls[1338])

// Use in application
const config = {
  webUrl: urls[3000],
  apiUrl: urls[1337],
  socketUrl: urls[1338]
}
```


# Initialization (new Sandbox)
Source: https://docs.fermion.app/coding-sandbox/methods/initialization

Learn how to initialize a new Fermion Sandbox client before creating containers.

Before you can create or manage containers, you must first initialize the Fermion Sandbox client. The `Sandbox({ apiKey })` constructor establishes a secure connection between your application and Fermion’s backend infrastructure, authenticating every subsequent operation you perform. This step does not immediately spin up a container, instead, it prepares the client instance for later actions such as creating new sandboxes, reconnecting to saved sessions, or running commands.

### `new Sandbox({ apiKey })`

**Description:**
Creates a new Sandbox client instance. This does not create a container yet - call `create()` or `fromSnippet()` after initialization.

**Parameters:**

| Parameter | Type   | Required | Description                             |
| --------- | ------ | -------- | --------------------------------------- |
| apiKey    | string | Yes      | Your Fermion API key from the dashboard |

**Returns:**
`Sandbox` instance

**Example:**

```typescript theme={null}
import { Sandbox } from '@fermion-app/sandbox'

const sandbox = new Sandbox({
  apiKey: process.env.FERMION_API_KEY
})
```


# Is Connected
Source: https://docs.fermion.app/coding-sandbox/methods/is-connected

Check whether the current sandbox session is actively connected via WebSocket.

The `isConnected()` method provides a quick way to verify whether your current sandbox instance is actively connected to Fermion’s infrastructure.

### `isConnected()`

**Description:**
Checks if the WebSocket connection to the sandbox is currently active.

**Parameters:**
None

**Returns:**
`boolean` - `true` if connected, `false` otherwise

**Example:**

```typescript theme={null}
console.log(sandbox.isConnected()) // false

await sandbox.create({ shouldBackupFilesystem: false })
console.log(sandbox.isConnected()) // true
```


# Execute Commands inside your Sandbox
Source: https://docs.fermion.app/coding-sandbox/methods/run-command

Execute short, non-streaming commands within a Fermion Sandbox and return stdout and stderr once complete.

The `runCommand()` method executes a single short-lived command inside your active sandbox container and waits until it finishes before returning the output. It’s ideal for quick tasks that complete within a few seconds: such as listing directories, checking Node.js or Python versions, or running lightweight scripts.

This method runs the command synchronously and captures both `stdout` and `stderr` once the execution is complete. Because it is optimized for speed and simplicity, `runCommand()` has a strict 5-second execution limit and does not support streaming output.

### `runCommand(options)`

**Description:**
Executes a short command (\< 5 seconds) and waits for completion. For longer operations, use `runStreamingCommand()`.

**Parameters:**

| Parameter | Type      | Required | Description                                       |
| --------- | --------- | -------- | ------------------------------------------------- |
| cmd       | string    | Yes      | Command to execute (e.g., 'node', 'python', 'ls') |
| args      | string\[] | No       | Array of command arguments                        |

**Returns:**

```typescript theme={null}
Promise<{
  stdout: string  // Standard output
  stderr: string  // Standard error
}>
```

**Example:**

```typescript theme={null}
// Simple command
const result = await sandbox.runCommand({
  cmd: 'pwd'
})
console.log('Current dir:', result.stdout)
```

**Limitations:**

* **5 second maximum** : Command will timeout
* No streaming - must wait for completion
* No exit code returned (use `runStreamingCommand` if you need it)


# Execute Long Running Commands inside your Sandbox
Source: https://docs.fermion.app/coding-sandbox/methods/run-streaming-command

Execute long-running commands with real-time stdout and stderr streaming inside a Fermion Sandbox.

The `runStreamingCommand()` method is designed for executing long-running or interactive commands inside a sandbox while receiving **real-time output streams**.

### `runStreamingCommand(options)`

**Description:**
Executes a long-running command with real-time output streaming. Callbacks are invoked as data arrives.

**Parameters:**

| Parameter | Type                   | Required | Description                           |
| --------- | ---------------------- | -------- | ------------------------------------- |
| cmd       | string                 | Yes      | Command to execute                    |
| args      | string\[]              | Yes      | Array of command arguments            |
| stdin     | string                 | No       | Standard input to send to the command |
| onStdout  | (data: string) => void | No       | Callback for stdout data chunks       |
| onStderr  | (data: string) => void | No       | Callback for stderr data chunks       |

**Returns:**

```typescript theme={null}
Promise<{
  stdout: string   // Complete accumulated output
  stderr: string   // Complete accumulated errors
  exitCode: number // Process exit code (0 = success)
}>
```

**Example:**

```typescript theme={null}
// Basic streaming
const result = await sandbox.runStreamingCommand({
  cmd: 'npm',
  args: ['install', 'express'],
  onStdout: (data) => console.log(data.trim()),
  onStderr: (data) => console.error(data.trim())
})
console.log('Exit code:', result.exitCode)

// With stdin
const result = await sandbox.runStreamingCommand({
	cmd: 'node',
	args: ['-e', 'process.stdin.on("data", d => console.log(d.toString()))'],
	stdin: 'Hello from stdin\n'
})
```

**Path Handling:**

When passing file paths or directory paths as command arguments, you can use the `~/` shorthand notation, which the shell automatically expands to the user's home directory (`/home/damner`).

**Examples:**

* `~/file.js` expands to `/home/damner/file.js`
* `~/project/script.sh` expands to `/home/damner/project/script.sh`
* `~/code/app.py` expands to `/home/damner/code/app.py`


# Get Session ID
Source: https://docs.fermion.app/coding-sandbox/methods/session-id

Retrieve the current sandbox session ID, or null if no active session exists.

The `getSessionId()` method returns the unique **session ID** associated with your active sandbox connection. This ID identifies the live session currently linked to your WebSocket connection.

### `getSessionId()`

**Description:**
Returns the current sandbox session ID, or null if not connected.

**Parameters:**
None

**Returns:**
`string | null` - Session ID or null

**Example:**

```typescript theme={null}
await sandbox.create({ shouldBackupFilesystem: false })
console.log(sandbox.getSessionId()) // 'session-abc123'
```

<Note>
  Session ID is different from snippet ID. Session is temporary, snippet is persistent.
</Note>

***


# Write to files inside your Sandbox Instance
Source: https://docs.fermion.app/coding-sandbox/methods/write-file

Write text or binary files to the sandbox filesystem with automatic directory creation.

The `writeFile()` method allows you to create or overwrite files inside your sandbox’s isolated filesystem. It supports both **text** and **binary** content. All file paths must begin with the absolute sandbox path `/home/damner`.

### `writeFile(options)`

**Description:**
Writes a file to the sandbox filesystem. Supports both text and binary content.

**Parameters:**

| Parameter | Type                  | Required | Description                                |
| --------- | --------------------- | -------- | ------------------------------------------ |
| path      | string                | Yes      | File path (must start with `/home/damner`) |
| content   | string \| ArrayBuffer | Yes      | File content (text string or binary data)  |

**Returns:**
`Promise<void>` - Resolves when write is complete

**Example:**

````typescript theme={null}
// Text file
await sandbox.writeFile({
  path: '/home/damner/script.js',
  content: 'console.log("Hello World")'
})

**Path Handling:**
```typescript
// Valid paths
await sandbox.writeFile({ path: '/home/damner/file.js', content: '...' })

// Invalid paths
await sandbox.writeFile({ path: '/tmp/file.js', content: '...' })
await sandbox.writeFile({ path: 'relative/file.js', content: '...' })
await sandbox.writeFile({ path: './file.js', content: '...' })
````

***


# Get Container Details
Source: https://docs.fermion.app/coding-sandbox/python-sdk/container-details

Retrieve container connection details including subdomain and secure access token using the Python SDK.

The `get_container_details()` method provides low-level connection information for the currently active sandbox container. It returns a dictionary containing the **container subdomain** and **playground access token**, which are used internally to establish and maintain a secure WebSocket connection between your client and Fermion’s backend infrastructure.

***

### `get_container_details() -> Optional[ContainerDetails]`

**Description:**\
Returns container connection details, including the subdomain and secure access token.\
If no sandbox is currently connected, returns `None`.

***

**Parameters:**\
*None*

***

**Returns:**
`ContainerDetails` object or `None`. The `ContainerDetails` object has the following attributes:

* `subdomain: str` - Container subdomain
* `playground_container_access_token: str` - Secure access token

**Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    details = sandbox.get_container_details()

    if details:
        print("Subdomain:", details.subdomain)
        print("Access Token:", details.playground_container_access_token)
    else:
        print("No active container connection.")

asyncio.run(main())
```

<Warning>
  The access token is sensitive. Do not expose it in logs or UI.
</Warning>


# Create and Spin Up a New Sandbox Instance
Source: https://docs.fermion.app/coding-sandbox/python-sdk/create

Provision a new Fermion Sandbox container with optional persistence or repository cloning using the Python SDK.

The `create()` method provisions a brand-new sandbox container within Fermion’s secure cloud infrastructure.\
When invoked, it initializes a clean Linux environment, configures your session, and establishes a WebSocket connection for real-time interaction.

Depending on the parameters you provide, the sandbox can be either **ephemeral** (short-lived and automatically destroyed on disconnect) or **persistent** (saved for later reuse).

You can also optionally **clone a Git repository** during provisioning, allowing you to start from existing codebases or templates.\
The provisioning process typically completes within a few seconds, after which the sandbox is ready to execute commands, perform file operations, or run servers.

This method returns a unique `snippet_id`, which can be stored and reused to reconnect to the same environment later.

***

## `async create(should_backup_filesystem: bool, git_repo_url: Optional[str] = None) -> Dict[str, str]`

**Description:**\
Creates and provisions a new sandbox container.\
This process includes:

1. Creating a playground snippet
2. Starting a session
3. Waiting for container provisioning (polling with \~500 ms intervals)
4. Establishing a WebSocket connection
5. Waiting for the container to be ready
6. Optionally cloning a Git repository

***

**Parameters:**

| Parameter                  | Type   | Required | Default | Description                                                                   |
| -------------------------- | ------ | -------- | ------- | ----------------------------------------------------------------------------- |
| `should_backup_filesystem` | `bool` | Yes      | -       | If `True`, files persist after disconnect. If `False`, everything is deleted. |
| `git_repo_url`             | `str`  | No       | `None`  | GitHub repository URL to clone on startup.                                    |

***

**Returns:**\
`Dict[str, str]` : Dictionary containing `playgroundSnippetId` key with the unique **snippet ID** for this sandbox session.\
Store this ID to reconnect or recreate the same environment later.

***

#### Basic sandbox

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")

    # Ephemeral Sandbox
    result = await sandbox.create(should_backup_filesystem=False)
    snippet_id = result['playgroundSnippetId']
    print("Ephemeral sandbox created with ID:", snippet_id)

    # Persistent Sandbox
    result = await sandbox.create(should_backup_filesystem=True)
    snippet_id = result['playgroundSnippetId']
    print("Persistent sandbox created with ID:", snippet_id)

    # With git repository
    result = await sandbox.create(
        should_backup_filesystem=True,
        git_repo_url="https://github.com/username/repo.git"
    )
    snippet_id = result['playgroundSnippetId']
    print("Sandbox created and repo cloned! Snippet ID:", snippet_id)

asyncio.run(main())
```


# Disconnect from the Sandbox Instance
Source: https://docs.fermion.app/coding-sandbox/python-sdk/disconnect

Gracefully close the WebSocket connection and clean up sandbox resources using the Python SDK.

## `disconnect()`

The `disconnect()` method gracefully terminates your active sandbox session by closing the WebSocket connection and releasing all associated resources. This ensures that all running processes are stopped, the session is closed cleanly, and the container is freed up for reuse.

***

### `async disconnect() -> None`

**Description:**\
Gracefully terminates your active sandbox session and releases all underlying resources.

***

**Parameters:**\
*None*

***

**Returns:**\
`None`: Resolves when disconnection and cleanup are complete.

***

### **Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    # Initialize and create a new sandbox
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    # Perform your tasks
    result = await sandbox.run_command(cmd="python3", args=["--version"])
    print("Python version:", result.stdout)

    # Always clean up when finished
    await sandbox.disconnect()
    print("Sandbox disconnected successfully.")

asyncio.run(main())
```


# Expose Ports from Sandbox for a Public HTTPS URL
Source: https://docs.fermion.app/coding-sandbox/python-sdk/expose-port

Expose a sandbox port publicly over HTTPS and access live web services running inside the container using the Python SDK.

The `expose_port()` method provides a **public HTTPS URL** that maps directly to a specific port running inside your sandbox container.\
Fermion automatically supports ports **3000**, **1337**, and **1338**, allowing you to host web servers, APIs, or other networked services securely and access them from anywhere.

When you start a server inside your sandbox (for example, using `python -m http.server` or `node server.js`), you can call `expose_port(port)` to instantly retrieve a URL in the format:`https://{subdomain}-{port}.run-code.com`

This allows you to preview, test, and share live web apps or APIs running within your sandbox.

***

### `async expose_port(port: Literal[3000, 1337, 1338]) -> str`

**Description:**\
Returns the public HTTPS URL for a specific port inside the sandbox.\
Currently, Fermion supports public exposure for ports **3000**, **1337**, and **1338**.

***

**Parameters:**

| Parameter | Type                        | Required | Description                                            |
| --------- | --------------------------- | -------- | ------------------------------------------------------ |
| `port`    | `Literal[3000, 1337, 1338]` | Yes      | Port number (must be one of `3000`, `1337`, or `1338`) |

***

**Returns:**\
`str` : Public HTTPS URL in the format `https://{subdomain}-{port}.run-code.com`.

***

**Example - Start and expose a Node.js server**

```python theme={null}
import asyncio
import time
from fermion_sandbox import Sandbox
import requests

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    # Write a simple Node.js server
    await sandbox.write_file(
        path="/home/damner/server.js",
        content="""
const http = require('http');
http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello from Fermion!');
}).listen(3000, () => {
  console.log('Server running on port 3000');
});
"""
    )

    # Run the server in the background with streaming output
    server_task = asyncio.create_task(
        sandbox.run_streaming_command(
            cmd="node",
            args=["/home/damner/server.js"],
            on_stdout=lambda data: print("[stdout]", data.strip())
        )
    )

    # Wait briefly for the server to start
    await asyncio.sleep(2)

    # Retrieve the public HTTPS URL for the exposed port
    url = await sandbox.expose_port(3000)
    print("Access your server at:", url)
    # Example output: https://abc123xyz-3000.run-code.com

    # Test the server.
    response = requests.get(url)
    print(response.text)  # Output: Hello from Fermion!

asyncio.run(main())
```


# Create a Sandbox Instance Using Snippet ID
Source: https://docs.fermion.app/coding-sandbox/python-sdk/from-snippet

Recreate a sandbox with the same file system as a previous one using its snippet ID in the Python SDK.

The `from_snippet()` method allows you to create a new sandbox that shares the **same file system and state** as a previously created sandbox, using its unique snippet ID. This is particularly useful when you’ve created a sandbox with `should_backup_filesystem=True` and want to **resume work later** without losing any files or progress.

***

## `async from_snippet(playground_snippet_id: str) -> None`

**Description:**\
Recreates a sandbox using the same file system as a previous sandbox session identified by its snippet ID.

***

**Parameters:**

| Parameter               | Type  | Required | Description                                                                                    |
| ----------------------- | ----- | -------- | ---------------------------------------------------------------------------------------------- |
| `playground_snippet_id` | `str` | Yes      | The snippet ID returned from a previous `create()` call (use `result['playgroundSnippetId']`). |

***

**Returns:**\
`None`: Resolves when the sandbox has successfully connected and restored the previous environment.

***

### **Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    # --- Session 1: Create a persistent sandbox ---
    sandbox1 = Sandbox(api_key="your-api-key")

    # Create a sandbox with persistent filesystem
    result = await sandbox1.create(should_backup_filesystem=True)
    snippet_id = result['playgroundSnippetId']

    # Write a file to the sandbox
    await sandbox1.write_file(path="/home/damner/data.txt", content="saved")

    # Disconnect but keep the filesystem backed up
    await sandbox1.disconnect()

    # --- Session 2: Resume using the same filesystem ---
    sandbox2 = Sandbox(api_key="your-api-key")

    # Reconnect using the saved snippet ID
    await sandbox2.from_snippet(playground_snippet_id=snippet_id)

    # Read the previously saved file
    response = await sandbox2.get_file("/home/damner/data.txt")
    file_content = response.text
    print(file_content)  # Output: "saved"

asyncio.run(main())
```


# Retrieve Files from Your Sandbox Instance
Source: https://docs.fermion.app/coding-sandbox/python-sdk/get-file

Retrieve text or binary files from the sandbox filesystem using the Python SDK.

The `get_file()` method retrieves a file from your sandbox's filesystem and returns its contents.\
Depending on the type of file, you can read the data as **text**, **binary bytes**, or even parse it as **JSON**.

All file paths must start with the absolute path `/home/damner` to ensure access is limited to the sandbox's isolated workspace.\
If the requested file doesn't exist or the path is invalid, an error will be raised.

***

### `async get_file(path: str) -> httpx.Response`

**Description:**\
Retrieves a file from the sandbox filesystem. Returns an `httpx.Response` object that you can use to read the content as text, bytes, or parse as JSON.

***

**Parameters:**

| Parameter | Type  | Required | Default | Description                                |
| --------- | ----- | -------- | ------- | ------------------------------------------ |
| `path`    | `str` | Yes      | —       | File path (must start with `/home/damner`) |

***

**Returns:**\
`httpx.Response`: Response object with the following methods:

* `.text` - Read as string (property)
* `.content` - Read as bytes (property)
* `.read()` - Read as bytes (method)
* `.json()` - Parse as JSON (method)

Raises an exception if the file does not exist or the path is invalid.

***

**Examples**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=True)

    # Read a Python file as text
    response = await sandbox.get_file("/home/damner/script.py")
    content = response.text
    print(content)

    # Read a binary file
    response = await sandbox.get_file("/home/damner/data.bin")
    binary_data = response.content

    # Read and parse JSON
    response = await sandbox.get_file("/home/damner/config.json")
    config = response.json()

asyncio.run(main())
```


# Retrieve Public URLs for Exposed Ports
Source: https://docs.fermion.app/coding-sandbox/python-sdk/get-public-urls

Retrieve all public HTTPS URLs for exposed sandbox ports (3000, 1337, 1338) using the Python SDK.

The `get_public_urls()` method returns all available **public HTTPS endpoints** for your active sandbox container in a single dictionary.

By default, Fermion automatically exposes ports **3000**, **1337**, and **1338**, each corresponding to its own unique public URL.\
This is useful for connecting multiple running services inside your sandbox, for example: a frontend (port 3000), API (port 1337), and WebSocket server (port 1338).

***

### `get_public_urls() -> dict[int, str]`

**Description:**\
Retrieves all currently available public HTTPS URLs for your sandbox, mapped by port number.

***

**Parameters:**\
*None*

***

**Returns:**

```python theme={null}
{
  3000: str,  # e.g. "https://abc123xyz-3000.run-code.com"
  1337: str,  # e.g. "https://abc123xyz-1337.run-code.com"
  1338: str   # e.g. "https://abc123xyz-1338.run-code.com"
}
```

**Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=True)

    urls = sandbox.get_public_urls()

    print("Available Public URLs:")
    print("Port 3000:", urls[3000])
    print("Port 1337:", urls[1337])
    print("Port 1338:", urls[1338])

    # Example usage in an app config
    config = {
        "web_url": urls[3000],
        "api_url": urls[1337],
        "socket_url": urls[1338]
    }

    print("App Configuration:", config)

asyncio.run(main())
```


# Initialization (Sandbox)
Source: https://docs.fermion.app/coding-sandbox/python-sdk/initialization

Learn how to initialize a new Fermion Sandbox client before creating containers using the Python SDK.

Before you can create or manage containers, you must first initialize the Fermion Sandbox client in Python. The `Sandbox(api_key=...)` constructor establishes a secure connection between your Python application and Fermion’s backend infrastructure, authenticating every subsequent operation you perform.

This step **does not immediately create a container** and instead, it prepares the client instance for later actions such as creating sandboxes, reconnecting to existing sessions, or running commands.

***

### `Sandbox(api_key: str)`

**Description:**\
Creates a new Sandbox client instance. This does not create a container yet, you will need to call `create()` or `from_snippet()` after initialization.

**Parameters:**

| Parameter | Type  | Required | Description                             |
| --------- | ----- | -------- | --------------------------------------- |
| `api_key` | `str` | Yes      | Your Fermion API key from the dashboard |

**Returns:**\
`Sandbox` instance

***

### **Example:**

```python theme={null}
from fermion_sandbox import Sandbox

# Initialize the Fermion Sandbox client
sandbox = Sandbox(api_key="your-api-key")
```


# Is Connected
Source: https://docs.fermion.app/coding-sandbox/python-sdk/is-connected

Check whether the current sandbox session is actively connected via WebSocket using the Python SDK.

The `is_connected()` method provides a quick way to verify whether your current sandbox instance is actively connected to Fermion’s backend infrastructure.

This can be useful for checking the session state before running commands, writing files, or performing other operations that require an active connection.

***

### `is_connected() -> bool`

**Description:**\
Checks if the WebSocket connection to the sandbox is currently active.

***

**Parameters:**\
*None*

***

**Returns:**\
`bool` : `True` if the sandbox is connected, `False` otherwise.

***

### **Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")

    # Check initial connection state
    print(sandbox.is_connected())  # False

    # Create a new sandbox
    await sandbox.create(should_backup_filesystem=False)
    print(sandbox.is_connected())  # True

    # Disconnect from the sandbox
    await sandbox.disconnect()
    print(sandbox.is_connected())  # False

asyncio.run(main())
```


# quick_run() Method
Source: https://docs.fermion.app/coding-sandbox/python-sdk/quick-run

Execute code instantly in multiple programming languages using the quick_run method in Python.

The **`quick_run()`** method provides a fast and secure way to execute code directly within your Python application. It supports **ten popular runtimes**, including **Python, Java, C++, Node.js**, and more.

<Note>
  Before calling `quick_run()`, you must first connect to the sandbox using either `await create()` or `await from_snippet()`. The sandbox must be active before you can execute any code.
</Note>

## Supported Languages

The following programming languages are supported by the `quick_run()` method.

<Columns>
  <Card title="C / C++" icon="C" />

  <Card title="Java" icon="java" />

  <Card title="Python" icon="python" />

  <Card title="Node.js" icon="node-js" />

  <Card title="SQLite / MySQL" icon="database" />

  <Card title="Go" icon="golang" />

  <Card title="Rust" icon="rust" />

  <Card title=".NET (C#)" icon="hashtag" />
</Columns>

***

## Method Signature

### `async quick_run(runtime: Literal['C', 'C++', 'Java', 'Python', 'Node.js', 'SQLite', 'MySQL', 'Go', 'Rust', '.NET'], source_code: str, stdin: Optional[str] = None, expected_output: Optional[str] = None, additional_files_as_zip: Optional[str] = None) -> DecodedRunResult`

**Description:**\
Executes code using the DSA execution API and returns the results. This method provides a simple way to execute code in various languages without needing to set up a full sandbox container.

***

## Method Parameters

The `quick_run()` method takes a set of parameters that define how your code will execute. Some are required, while others allow input, validation, or additional file support.

***

### Required Parameters

| Parameter     | Type | Description                                                                                                   |
| ------------- | ---- | ------------------------------------------------------------------------------------------------------------- |
| `runtime`     | str  | The programming language to execute (must match one of the supported runtimes above).                         |
| `source_code` | str  | The source code to execute inside the sandbox. Use triple quotes (`"""`) or backticks for multi-line strings. |

***

### Optional Parameters

| Parameter                 | Type | Description                                                                                |
| ------------------------- | ---- | ------------------------------------------------------------------------------------------ |
| `stdin`                   | str  | Input data passed to the program’s standard input.                                         |
| `expected_output`         | str  | Expected output for validation purposes.                                                   |
| `additional_files_as_zip` | str  | Base64URL-encoded ZIP file containing extra files (e.g., database schema or dependencies). |

***

## Execution Results

The `quick_run()` method returns a **`DecodedRunResult`** object containing detailed execution results: status, output, timing, and resource usage.

| Field                                             | Description                                                                                                                                                                                                                                                                                            |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `run_status`                                      | Final execution result (RunStatus enum). Use `.value` to get the string value. Possible values: `"successful"`, `"compilation-error"`, `"time-limit-exceeded"`, `"wrong-answer"`, `"non-zero-exit-code"`, `"died-sigsev"`, `"died-sigfpe"`, `"died-sigabrt"`, `"internal-isolate-error"`, `"unknown"`. |
| `program_run_data`                                | Object holding detailed execution data like stdout, stderr, CPU time, and memory usage. Returns `None` if execution hasn't finished.                                                                                                                                                                   |
| `program_run_data.stdout`                         | Program's standard output (already decoded by the SDK, not Base64URL).                                                                                                                                                                                                                                 |
| `program_run_data.stderr`                         | Program's error output (already decoded by the SDK, not Base64URL).                                                                                                                                                                                                                                    |
| `program_run_data.cpu_time_used_in_milliseconds`  | CPU time consumed during execution (milliseconds).                                                                                                                                                                                                                                                     |
| `program_run_data.wall_time_used_in_milliseconds` | Real (wall-clock) time elapsed (milliseconds).                                                                                                                                                                                                                                                         |
| `program_run_data.memory_used_in_kilobyte`        | Memory used during execution (kilobytes).                                                                                                                                                                                                                                                              |
| `program_run_data.exit_code`                      | Program's exit code (0 indicates success).                                                                                                                                                                                                                                                             |
| `program_run_data.exit_signal`                    | Termination signal if the process was killed, or 0 otherwise.                                                                                                                                                                                                                                          |
| `compiler_output_after_compilation`               | Compiler output (for compiled languages). Already decoded by SDK; returns `None` for interpreted languages.                                                                                                                                                                                            |
| `finished_at`                                     | ISO 8601 UTC timestamp when execution finished (e.g., `"2025-11-06T08:14:10.127Z"`).                                                                                                                                                                                                                   |

***

### Validation (if you provided `expected_output`)

If you supplied an `expected_output` when running your code, QuickRun automatically compares the actual output with your expected value. The comparison result is reflected in the `run_status` field:

* If the output matches: `run_status.value` will be `"successful"`
* If the output doesn't match: `run_status.value` will be `"wrong-answer"`
* If there's a compilation error: `run_status.value` will be `"compilation-error"`
* If there's a runtime error: `run_status.value` will be `"non-zero-exit-code"` or another error status

This allows for quick correctness checks, ideal for grading systems, test runners, or automated assessments.

***

## How to Use quick\_run()

Below are examples showing how to use `quick_run()` in Python.

<CodeGroup>
  ```python hello_world.py theme={null}
  import asyncio
  from fermion_sandbox import Sandbox

  async def main():
      sandbox = Sandbox(api_key="fermion-api-key")

      # Connect to sandbox first
      await sandbox.create(should_backup_filesystem=False)

      result = await sandbox.quick_run(
          runtime="Python",
          source_code='print("Hello, World!")'
      )

      # Output is already decoded
      if result.program_run_data:
          output = result.program_run_data.stdout
          print(output)          # "Hello, World!\n"
      print(result.run_status.value)  # "successful"

  asyncio.run(main())
  ```

  ```python with_input.py theme={null}
  import asyncio
  from fermion_sandbox import Sandbox

  async def main():
      # Initialize the sandbox with your API key
      sandbox = Sandbox(api_key="fermion-api-key")

      # Connect to the sandbox first (required)
      await sandbox.create(should_backup_filesystem=False)

      # Run the Python code with input
      result = await sandbox.quick_run(
          runtime="Python",
          source_code='name = input()\nprint(f"Hello, {name}!")',
          stdin="Alice"
      )

      # Output is already decoded by the SDK
      if result.program_run_data:
          print(result.program_run_data.stdout)  # "Hello, Alice!\n"

  asyncio.run(main())
  ```
</CodeGroup>

## Error Handling

Even well-written code can fail. The `quick_run()` method provides clear and structured feedback to help you identify and debug issues efficiently.\
Common failure types include **compilation errors**, **runtime exceptions**, and **timeouts**.\
Each is explained below with example usage.

<AccordionGroup>
  <Accordion title="Compilation Errors" icon="terminal">
    Compilation errors occur when the source code cannot be compiled, typically due to syntax issues or missing elements. The `run_status.value` will be `"compilation-error"`, and the compiler output can be accessed through `compiler_output_after_compilation`.

    ```python theme={null}
    import asyncio
    from fermion_sandbox import Sandbox

    async def main():
        sandbox = Sandbox(api_key="fermion-api-key")
        await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

        result = await sandbox.quick_run(
            runtime="Java",
            source_code='public class Main { // Missing closing brace'
        )

        print(result.run_status.value)  # "compilation-error"

        if result.compiler_output_after_compilation:
            # Output is already decoded by the SDK
            compiler_output = result.compiler_output_after_compilation
            print(compiler_output)  # Shows compiler error messages

    asyncio.run(main())
    ```
  </Accordion>

  <Accordion title="Runtime Errors" icon="business-time">
    Runtime errors happen when the code compiles successfully but fails during execution, for example, dividing by zero or accessing invalid memory. In such cases, `run_status.value` will be `"non-zero-exit-code"`, and the error details are available in `program_run_data.stderr`.

    ```python theme={null}
    import asyncio
    from fermion_sandbox import Sandbox

    async def main():
        sandbox = Sandbox(api_key="fermion-api-key")
        await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

        result = await sandbox.quick_run(
            runtime="Python",
            source_code='print(1 / 0)'  # Division by zero
        )

        print(result.run_status.value)  # "non-zero-exit-code" or another error status

        if result.program_run_data and result.program_run_data.stderr:
            stderr_output = result.program_run_data.stderr
            print(stderr_output)  # Shows error details

    asyncio.run(main())
    ```
  </Accordion>

  <Accordion title="Timeout Errors" icon="timer">
    Timeout errors occur when a program runs beyond the allowed execution time. In such cases, the `run_status.value` will be `"time-limit-exceeded"`.

    ```python theme={null}
    import asyncio
    from fermion_sandbox import Sandbox

    async def main():
        sandbox = Sandbox(api_key="fermion-api-key")
        await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

        result = await sandbox.quick_run(
            runtime="Python",
            source_code='while True: pass'  # Infinite loop
        )

        print(result.run_status.value)  # "time-limit-exceeded"

    asyncio.run(main())
    ```
  </Accordion>
</AccordionGroup>

## Best Practices

* **Connect to the sandbox first:** Always call `await create()` or `await from_snippet()` before using `quick_run()`.
* **Always check `run_status` first:** Before reading output, confirm the code executed successfully (`run_status.value == "successful"`).
* **Ensure `program_run_data` is not `None`:** Verify that the result object includes `program_run_data` before accessing its properties.
* **Output is automatically decoded:** The SDK automatically decodes `stdout`, `stderr`, and `compiler_output_after_compilation`. You can use them directly without additional decoding.
* **Use `expected_output` for automated validation:** If the output matches your expected value, `run_status.value` will be `"successful"`, otherwise it will be `"wrong-answer"`.
* **Handle errors gracefully:** Check `run_status.value` and read `stderr` to display meaningful error messages.
* **Validate user input:** Always validate and sanitize user-submitted code before execution to ensure safety and reliability.

***

## Performance Tips

* Typical code execution time: **1–3 seconds**
* **Compiled languages** (C++, Java, Rust) may take slightly longer due to compilation overhead.
* **Interpreted languages** (Python, Node.js) generally start faster.
* **Database runtimes** (SQLite, MySQL) depend on query complexity and data size.

***

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How long does code execution take?">
    Code execution typically completes within **1–3 seconds**, depending on the language,
    code complexity, and whether compilation is required.\
    Interpreted languages like **Python** or **Node.js** tend to execute faster, while compiled
    languages such as **Java** or **Rust** may take slightly longer.
  </Accordion>

  <Accordion title="What if my code needs external files?">
    You can include additional files by encoding them as a **Base64 ZIP** and passing
    them through the **`additional_files_as_zip`** parameter.\
    This allows your program to access dependencies, data files, or assets during execution.
  </Accordion>

  <Accordion title="Can I run code that reads from files?">
    Yes. Your program can read from files provided through **`additional_files_as_zip`**,\
    or you can simulate user input using the **`stdin`** parameter for simpler text-based input.
  </Accordion>

  <Accordion title="What happens if my code runs forever?">
    Each code execution has a **time limit** to prevent infinite loops or unresponsive code.\
    If your program exceeds this limit, it's automatically stopped and marked as
    **`time-limit-exceeded`** in the result object.
  </Accordion>

  <Accordion title="Is the execution environment safe?">
    Absolutely. All code runs inside a **secure, isolated sandbox** with strict resource and
    permission controls. This ensures your application and data remain safe from malicious or runaway code.
  </Accordion>
</AccordionGroup>


# Execute Commands Inside Your Sandbox
Source: https://docs.fermion.app/coding-sandbox/python-sdk/run-command

Execute short, non-streaming commands within a Fermion Sandbox and return stdout and stderr once complete using the Python SDK.

The `run_command()` method executes a short-lived command inside your active sandbox container and waits for it to finish before returning the output.

It’s ideal for quick, synchronous tasks such as listing files, checking Python or Node.js versions, or running lightweight scripts that complete within a few seconds.

This method captures both `stdout` and `stderr` once the command completes. Because it’s optimized for speed and simplicity, `run_command()` has a **strict 5-second execution limit** and does **not support streaming output**.

***

### `async run_command(cmd: str, args: Optional[List[str]] = None) -> CommandResult`

**Description:**\
Executes a short command (\< 5 seconds) and returns its standard output and standard error.\
For longer-running or streaming processes, use `run_streaming_command()` instead.

***

**Parameters:**

| Parameter | Type        | Required | Description                                             |
| --------- | ----------- | -------- | ------------------------------------------------------- |
| `cmd`     | `str`       | Yes      | Command to execute (e.g. `"python3"`, `"ls"`, `"echo"`) |
| `args`    | `List[str]` | No       | List of command arguments                               |

***

**Returns:**

`CommandResult` object with the following attributes:

* `stdout: str` - Standard output
* `stderr: str` - Standard error
* `exit_code: int` - Exit code (defaults to 0)

**Example:**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    # Run a simple shell command
    result = await sandbox.run_command(cmd="pwd")

    print("Current directory:", result.stdout)
    print("Exit code:", result.exit_code)

asyncio.run(main())
```

**Limitations:**

* **5 second maximum** : Command will timeout
* No streaming - must wait for completion
* Exit code is always 0 for this method (use `run_streaming_command()` if you need accurate exit codes)


# Execute Long-Running Commands Inside Your Sandbox
Source: https://docs.fermion.app/coding-sandbox/python-sdk/run-streaming-command

Execute long-running commands with real-time stdout and stderr streaming inside a Fermion Sandbox using the Python SDK.

The `run_streaming_command()` method is designed for executing **long-running or interactive commands** inside your sandbox while receiving **real-time output streams**.

Unlike `run_command()`, this method does not block until completion — it allows you to process live logs or incremental output as the command runs.

***

### `async run_streaming_command(cmd: str, args: Optional[List[str]] = None, stdin: Optional[str] = None, on_stdout: Optional[Callable[[str], None]] = None, on_stderr: Optional[Callable[[str], None]] = None) -> CommandResult`

**Description:**\
Executes a long-running command inside the sandbox and streams output in real time. Callbacks are triggered as new stdout or stderr data chunks arrive.

***

**Parameters:**

| Parameter   | Type                    | Required | Description                                        |
| ----------- | ----------------------- | -------- | -------------------------------------------------- |
| `cmd`       | `str`                   | Yes      | Command to execute (e.g., `"npm"`, `"python3"`)    |
| `args`      | `List[str]`             | No       | List of command arguments (defaults to empty list) |
| `stdin`     | `str`                   | No       | Optional standard input to send to the command     |
| `on_stdout` | `Callable[[str], None]` | No       | Callback function invoked when stdout data arrives |
| `on_stderr` | `Callable[[str], None]` | No       | Callback function invoked when stderr data arrives |

***

**Returns:**

`CommandResult` object with the following attributes:

* `stdout: str` - Complete accumulated output
* `stderr: str` - Complete accumulated error output
* `exit_code: int` - Process exit code (0 = success)

**Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    def handle_stdout(data: str):
        print("[stdout]", data.strip())

    def handle_stderr(data: str):
        print("[stderr]", data.strip())

    result = await sandbox.run_streaming_command(
        cmd="npm",
        args=["install", "express"],
        on_stdout=handle_stdout,
        on_stderr=handle_stderr
    )

    print("Exit code:", result.exit_code)

    # With stdin
    result = await sandbox.run_streaming_command(
        cmd="python3",
        args=["-c", 'import sys; [print(line.strip()) for line in sys.stdin]'],
        stdin="Hello from stdin\n"
    )

    print("Output:", result.stdout)

asyncio.run(main())
```


# Get Session ID
Source: https://docs.fermion.app/coding-sandbox/python-sdk/session-id

Retrieve the current sandbox session ID, or None if no active session exists using the Python SDK.

The `get_session_id()` method returns the unique **session ID** associated with your active sandbox connection.\
This ID identifies the currently live session linked to your WebSocket connection.

***

### `get_session_id() -> Optional[str]`

**Description:**\
Returns the current sandbox session ID, or `None` if there is no active session.

***

**Parameters:**\
*None*

***

**Returns:**\
`str` or `None` : The session ID if connected, otherwise `None`.

***

**Example**

```python theme={null}
import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")

    # No active session yet
    print(sandbox.get_session_id())  # None

    # Create a new sandbox
    await sandbox.create(should_backup_filesystem=False)

    # Retrieve the session ID
    print(sandbox.get_session_id())  # e.g. "session-abc123"

asyncio.run(main())
```


# Write to Files Inside Your Sandbox Instance
Source: https://docs.fermion.app/coding-sandbox/python-sdk/write-file

Write text or binary files to the sandbox filesystem with automatic directory creation using the Python SDK.

The `write_file()` method allows you to create or overwrite files inside your sandbox's isolated filesystem.\
It supports both **text** and **binary** content, making it flexible for handling scripts, configuration files, and assets such as images, JSON files, or compiled binaries.

All file paths must begin with the absolute sandbox path `/home/damner`.

***

### `async write_file(path: str, content: Union[str, bytes]) -> None`

**Description:**\
Writes a file to the sandbox filesystem. Supports both text (`str`) and binary (`bytes`) content.\
Automatically creates directories if they don't exist.

***

**Parameters:**

| Parameter | Type             | Required | Description                                |
| --------- | ---------------- | -------- | ------------------------------------------ |
| `path`    | `str`            | Yes      | File path (must start with `/home/damner`) |
| `content` | `str` or `bytes` | Yes      | File content (text string or binary data)  |

***

**Returns:**\
`None` : Resolves when the file write operation is complete.

***

**Examples**

```python theme={null}
import asyncio
import json
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="your-api-key")
    await sandbox.create(should_backup_filesystem=False)

    # Write a simple Python file
    await sandbox.write_file(
        path="/home/damner/script.py",
        content='print("Hello World")'
    )

    # Multi line content
    config = {
        "name": "my-app",
        "version": "1.0.0"
    }

    await sandbox.write_file(
        path="/home/damner/config.json",
        content=json.dumps(config, indent=2)
    )

asyncio.run(main())
```

**Path Handling**

```python theme={null}
# Valid paths (must start with /home/damner)

await sandbox.write_file(path="/home/damner/file.txt", content="data")
await sandbox.write_file(path="/home/damner/code/file.txt", content="data")
await sandbox.write_file(path="/home/damner/nested/dir/file.txt", content="data")

# Invalid paths
await sandbox.write_file(path="/tmp/file.txt", content="data")  # Error
await sandbox.write_file(path="relative/file.txt", content="data")  # Error
await sandbox.write_file(path="./file.txt", content="data")  # Error
```


# quickRun() Method
Source: https://docs.fermion.app/coding-sandbox/quick-run

Learn how to instantly execute code in multiple programming languages using the QuickRun method.

The **`quickRun()`** method provides a fast and secure way to execute code directly within your application. It has built-in support for ten popular runtimes: **Python, Java, C++, Node.js, etc**.

<Note>
  Before using `quickRun()`, you must first establish a connection to the sandbox by calling `create()` or `fromSnippet()`. The sandbox must be connected before executing code.
</Note>

## Supported Languages

The following languages can be executed with the help of the `quickRun()` method.

<Columns>
  <Card title="C / C++" icon="C" />

  <Card title="Java" icon="java" />

  <Card title="Python" icon="python" />

  <Card title="Node.js" icon="node-js" />

  <Card title="SQLite / MySQL" icon="database" />

  <Card title="Go" icon="golang" />

  <Card title="Rust" icon="rust" />

  <Card title=".NET (C#)" icon="hashtag" />
</Columns>

## Method Parameters

The `quickRun()` method accepts a set of parameters that define how your code will be executed. Some are required to run code successfully, while others let you customize execution behavior, provide input, or validate results.

***

### Required Parameters

These parameters are mandatory for every QuickRun execution. Without them, the method won't know what language to use or what code to run.

| Parameter    | Type   | Description                                                                                                                                           |
| ------------ | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `runtime`    | string | Specifies the programming language to execute (see the supported languages above).                                                                    |
| `sourceCode` | string | The actual source code to be executed within the sandbox environment. If the source code is multi-line, please use backticks (\`) to format the code. |

***

### Optional Parameters

Use these optional parameters to provide inputs, verify expected outputs, or include additional files required by your program.

| Parameter              | Type   | Description                                                                                    |
| ---------------------- | ------ | ---------------------------------------------------------------------------------------------- |
| `stdin`                | string | Input data passed to the program's standard input (like console input).                        |
| `expectedOutput`       | string | The expected output for validation                                                             |
| `additionalFilesAsZip` | string | Base64URL-encoded ZIP archive containing any extra files your program depends on. (SQL schema) |

***

### Execution Results

The `quickRun()` method returns a `runResult` object that holds detailed information about the execution outcome: whether it succeeded, failed, or encountered runtime or compilation issues.

| Field                                           | Description                                                                                                                                                                                                                                                                                                                                 |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`runStatus`**                                 | Indicates the final execution result. Possible values include `"successful"`, `"compilation-error"`, `"time-limit-exceeded"`, `"wrong-answer"`, `"non-zero-exit-code"`, `"died-sigsev"`, `"died-sigxfsz"`, `"died-sigfpe"`, `"died-sigabrt"`, `"internal-isolate-error"`, or `"unknown"`. Returns `null` if execution hasn't completed yet. |
| **`programRunData`**                            | An object containing detailed execution metrics and output. Returns `null` if execution hasn't completed yet.                                                                                                                                                                                                                               |
| **`programRunData.stdout`**                     | String containing everything the program printed to the standard output stream. The SDK automatically decodes this value, so you can use it directly without additional decoding.                                                                                                                                                           |
| **`programRunData.stderr`**                     | String containing any error messages or debug logs printed to the standard error stream. The SDK automatically decodes this value, so you can use it directly without additional decoding.                                                                                                                                                  |
| **`programRunData.cpuTimeUsedInMilliseconds`**  | Reports how long the code took to execute (CPU time), measured in milliseconds. Helpful for performance benchmarking or optimization.                                                                                                                                                                                                       |
| **`programRunData.wallTimeUsedInMilliseconds`** | Reports the wall-clock time (real time) taken for execution, measured in milliseconds.                                                                                                                                                                                                                                                      |
| **`programRunData.memoryUsedInKilobyte`**       | Indicates the total memory used during execution, measured in kilobytes.                                                                                                                                                                                                                                                                    |
| **`programRunData.exitCode`**                   | The exit code returned by the program (0 typically indicates success).                                                                                                                                                                                                                                                                      |
| **`programRunData.exitSignal`**                 | The exit signal if the process was terminated by a signal, or `null` otherwise.                                                                                                                                                                                                                                                             |
| **`compilerOutputAfterCompilation`**            | Compiler output (for compiled languages). The SDK automatically decodes this value, so you can use it directly without additional decoding. Returns `null` for interpreted languages or if there's no compiler output.                                                                                                                      |
| **`finishedAt`**                                | Timestamp marking when the execution completed, in ISO 8601 UTC format (e.g., `"2025-11-06T08:14:10.127Z"`). Returns `null` if execution hasn't completed yet.                                                                                                                                                                              |

***

### Validation (if you provided `expectedOutput`)

If you supplied an `expectedOutput` when running your code, QuickRun automatically compares the actual output with your expected value. The comparison result is reflected in the `runStatus` field:

* If the output matches: `runStatus` will be `"successful"`
* If the output doesn't match: `runStatus` will be `"wrong-answer"`
* If there's a compilation error: `runStatus` will be `"compilation-error"`
* If there's a runtime error: `runStatus` will be `"non-zero-exit-code"` or another error status

This allows for quick correctness checks, ideal for grading systems, test runners, or automated assessments.

***

## How to Use QuickRun

Here is a simple example on how you can use the `quickRun()` to execute code:

<CodeGroup>
  ```typescript helloWorld.ts theme={null}
  import { Sandbox } from '@fermion/sandbox'

  const sandbox = new Sandbox({ apiKey: 'fermion-api-key' })

  // Connect to sandbox first (required)
  await sandbox.create()

  const result = await sandbox.quickRun({
  	runtime: 'Python',
  	sourceCode: 'print("Hello, World!")'
  })

  // Output is already decoded by the SDK
  const output = result.programRunData?.stdout
  console.log(output) // Outputs: "Hello, World!\n"
  console.log(result.runStatus) // "successful"
  ```

  ```typescript withInput.ts theme={null}
  import { Sandbox } from '@fermion/sandbox'

  const sandbox = new Sandbox({ apiKey: 'fermion-api-key' })
  await sandbox.create()

  const result = await sandbox.quickRun({
  	runtime: 'Python',
  	sourceCode: 'name = input()\nprint(f"Hello, {name}!")',
  	stdin: 'Alice'
  })

  console.log(result.programRunData?.stdout) // "Hello, Alice!\n"
  ```
</CodeGroup>

## Error Handling

Even well-written code can fail, the `quickRun()` provides clear feedback to help you identify and debug errors efficiently. Common failure types include compilation errors, runtime exceptions, and timeouts. Each is detailed below with example usage.

<AccordionGroup>
  <Accordion title="Compilation Errors" icon="terminal">
    These occur when the code fails to compile due to syntax issues or missing elements. The `runStatus` will be set to **"compilation-error"**, and the compiler output can be found in `compilerOutputAfterCompilation`.

    ```typescript theme={null}
    import { Sandbox } from '@fermion/sandbox'

    const sandbox = new Sandbox({ apiKey: 'fermion-api-key' })
    await sandbox.create() // Connect first (required)

    const result = await sandbox.quickRun({
      runtime: 'Java',
      sourceCode: 'public class Main { // Missing closing brace'
    })

    console.log(result.runStatus) // "compilation-error"
    if (result.compilerOutputAfterCompilation) {
      // Output is already decoded by the SDK
      const compilerOutput = result.compilerOutputAfterCompilation
      console.log(compilerOutput) // Shows compiler error messages
    }
    ```
  </Accordion>

  <Accordion title="Runtime Errors" icon="business-time">
    Runtime errors happen when the program compiles successfully but fails during execution, such as dividing by zero or accessing invalid memory. In such cases, the `runStatus` will be **"non-zero-exit-code"** or another error status, and the error message appears in `programRunData.stderr`.

    ```typescript theme={null}
    import { Sandbox } from '@fermion/sandbox'

    const sandbox = new Sandbox({ apiKey: 'fermion-api-key' })
    await sandbox.create() // Connect first (required)

    const result = await sandbox.quickRun({
      runtime: 'Python',
      sourceCode: 'print(1 / 0)' // Division by zero
    })

    console.log(result.runStatus) // "non-zero-exit-code" or other error status
    if (result.programRunData?.stderr) {
      // Output is already decoded by the SDK
      const stderr = result.programRunData.stderr
      console.log(stderr) // Shows error details
    }
    ```
  </Accordion>

  <Accordion title="Timeout Errors" icon="timer">
    Timeout errors occur when a program runs beyond the allowed time limit, typically due to infinite loops or heavy computation. The `runStatus` will be **"time-limit-exceeded"**.

    ```typescript theme={null}
    import { Sandbox } from '@fermion/sandbox'

    const sandbox = new Sandbox({ apiKey: 'fermion-api-key' })
    await sandbox.create() // Connect first (required)

    const result = await sandbox.quickRun({
      runtime: 'Python',
      sourceCode: 'while True: pass' // Infinite loop
    })

    console.log(result.runStatus) // "time-limit-exceeded"
    ```
  </Accordion>
</AccordionGroup>

## Best Practices

* **Connect to sandbox first** : Always call `create()` or `fromSnippet()` before using `quickRun()`
* **Always check runStatus first** : Before looking at output, verify the code ran successfully (`runStatus === 'successful'`)
* **Check programRunData is not null** : Ensure `programRunData` exists before accessing its properties
* **Output is already decoded** : The SDK automatically decodes `stdout`, `stderr`, and `compilerOutputAfterCompilation`, so you can use them directly without additional decoding
* **Use expectedOutput for automated testing** : The system will set `runStatus` to `"successful"` if output matches, or `"wrong-answer"` if it doesn't
* **Handle errors gracefully** : Show helpful messages when code fails by checking `runStatus` and accessing `stderr` directly
* **Validate user input** : If users can submit code, validate it before execution

## Performance Tips

* Code execution typically takes 1-3 seconds
* Compilation languages (C++, Java, Rust) may take slightly longer
* Interpreted languages (Python, Node.js) start faster
* Database operations (SQLite, MySQL) depend on query complexity

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="How long does code execution take?">
    Code execution typically completes within **1–3 seconds**, depending on the programming
    language, code complexity, and whether compilation is required. Interpreted languages like
    Python or Node.js tend to execute faster, while compiled languages such as Java or Rust may take
    slightly longer.
  </Accordion>

  <Accordion title="What if my code needs external files?">
    You can include any required files by encoding them as a Base64 ZIP and passing them through the
    **`additionalFilesAsZip`** parameter. This allows your program to access external dependencies,
    data files, or assets during execution.
  </Accordion>

  <Accordion title="Can I run code that reads from files?">
    Yes. Your program can read from files provided through **`additionalFilesAsZip`**, or you can
    simulate user input using the **`stdin`** parameter for simpler text-based input.
  </Accordion>

  <Accordion title="What happens if my code runs forever?">
    Each code execution has a **time limit** to prevent infinite loops or unresponsive code. If your
    program exceeds this limit, it's automatically stopped and marked as **`TimeLimitExceeded`** in
    the result object.
  </Accordion>

  <Accordion title="Is the execution environment safe?">
    Absolutely. All code runs inside a **secure, isolated sandbox** with strict resource and
    permission controls. This ensures your application and data remain safe from malicious or
    runaway code.
  </Accordion>
</AccordionGroup>


# Community Features
Source: https://docs.fermion.app/community/community-features

Explore all the features available in Fermion communities, including channels, threads, polls, reactions, admin controls, and more, to engage and connect with your learners effectively.

There's a lot you can do. Fermion allows you to host communities in the way you want, which means, more customizations, features, and controls for you.

*Let's dig in and understand the different features.*

## Choose from private or public channels

*If you've ever used Slack, you can already relate to this feature*

At Fermion, you can choose between creating public channels or private channels, inside the same community, and all under your platform.

![Channels Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20163853/Screenshot-2024-09-20-at-4.38.47%E2%80%AFPM-1024x556.png)

## Students' privacy

One of the most important concerns people have while participating in communities is their personal information being revealed. To battle this, Fermion doesn't allow users to see any data, whether email or phone number, to be visible to other users. Only the user's name and profile picture are shown in the community.

Although as an instructor, you will be able to see all student's registered email.

## Message Reactions

Communicating is more fun with emojis - that's a fact, isn't it?

![Message Reactions Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20164428/Screenshot-2024-09-20-at-4.44.20%E2%80%AFPM-1024x319.png)

Add emojis as reactions to any message in the community and interact with your students. It works exactly how reactions work on any other social media platform - Instagram, WhatsApp, Slack, or Discord.

If you want to step up your community game, you can also add custom emojis specific to your community, apart from the basic emojis available.

## Conduct polls

You can also conduct quick polls within your community, to make decisions quickly and smoothly.

![Poll Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20170225/Screenshot-2024-09-20-at-5.02.19%E2%80%AFPM-1024x417.png)

Simply head to the poll option in the options tray, write your question and provide the options.

You can end the poll manually once you get the satisfactory number of responses.

## Tag and mention people

Tag people in the community, add mentions in messages and communicate in a better way.

![Tag People Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20170840/Screenshot-2024-09-20-at-5.08.33%E2%80%AFPM-1024x417.png)

Every time you tag someone, they will receive a browser notification, or an in-app notification, depending on their device.

## Add voice notes

Ditch long text messages and share quick audio notes with your community - it's like a norm in close knit communities now, isn't it?

![Voice Notes Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20172238/Screenshot-2024-09-20-at-5.22.31%E2%80%AFPM-1024x571.png)

## Dispatch emails from within the community

Feel like you're sharing an important message and want to make sure people pay more attention to it?

You can share it as an email too!

![Email Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20173206/Screenshot-2024-09-20-at-5.31.59%E2%80%AFPM-1024x479.png)

## Threads

With threads, you can create organized and detailed discussions around specific messages without adding clutter to a channel.

Personally, threads are a great way to continue conversations on relevant topics.

![Threads Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20173932/Screenshot-2024-09-20-at-5.39.27%E2%80%AFPM-1024x575.png)

On Fermion, you can use threads within your community to organise conversations better. You can also send messages inside a thread to the main channel - *just how slack works!*

## Channel settings

This feature brings to one of the most important area inside your community - the channel settings.

![Channel Settings Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20174847/Screenshot-2024-09-20-at-5.48.40%E2%80%AFPM-1024x501.png)

When you click on the channel name, a new modal like shown in the above picture opens up.

It gives you more controls to manage your channel settings. If you need to change your channel name, description, this is the place to do it.

Other than this, you can also make your public channel private and vice versa, manage your notifications and banned users.

## More admin controls

As an admin of your community, you have important controls like banning users, and deleting messages to maintain the peace and order of your communities.

At times, it gets imperative to strictly moderate your communities against any sort of spam or abuse. At times like these, you can use admin controls to resolve any issue.

When you hover over a user's message, you will see three dots. Upon clicking those three dots, you get options to ban the user or delete their message.

![Admin Controls Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20175625/Screenshot-2024-09-20-at-5.56.18%E2%80%AFPM-1024x501.png)

## Conclusion

It is extremely important to provide a seamless and beautiful experience to your students via a powerful community. Fermion allows you to provide exactly such a premium experience with rich tooling and infrastructure.

If you're looking to host your next technical course online or simply want to host an online community under your own platform, let's speak.

[Schedule a free online demo with us today.](https://sales.fermion.app/demo-call)


# Communities on Fermion
Source: https://docs.fermion.app/community/what-are-communities

Discover the community features on Fermion and learn how to connect, collaborate, and engage with instructors and learners.

To give a great learning experience to your students, it is important to bring your community under your platform. [Fermion](https://fermion.app/) offers you a sweet spot - one where you can host your community in a slack-like interface under your domain. Real-time communities on Fermion are your own private space where you can interact with your online audience. The community experience at Fermion is very similar to how Slack works. It comes with tons of features to give your audience a rich experience.

### What's special?

These features which give your audience a rich experience make the community so special. It's a unique blend with your platform and Slack, bringing a native white-labeled community inside your platform.

## How does it work?

**Step 1:** Head over to the community section from your instructor dashboard at Fermion.

![Step 1 Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20160408/Screenshot-2024-09-20-at-4.04.01%E2%80%AFPM-1024x483.png)

**Step 2:** Once you reach your school's community, this is what it will look like.

![Step 2 Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20160459/Screenshot-2024-09-20-at-4.04.52%E2%80%AFPM-1024x573.png)

**Step 3:** Create your first channel by clicking on "Create a channel".

![Step 3 Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20160800/Screenshot-2024-09-20-at-4.07.54%E2%80%AFPM-1024x572.png)

**Step 4:** You can choose to create a private channel or a public channel depending upon the kind of audience you'd like to cater to. Fill the basic metadata about your channel, like the channel name and description.

![Step 4 Screenshot](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/09/20162013/Screenshot-2024-09-20-at-4.20.06%E2%80%AFPM-1024x556.png)

*Voila! Your first channel is now ready. Share messages, and files and interact with your students in the best way!*

## Next steps

<Columns>
  <Card title="Explore community features" href="/community/community-features">
    Learn about channels, threads, polls, reactions, admin controls, and all the ways you can engage with your learners in Fermion communities.
  </Card>
</Columns>


# Contest Questions
Source: https://docs.fermion.app/contests/contest-questions

Learn how to add and configure different question types in your Fermion contest, including interactive coding labs, DSA coding labs, and quizzes.

[Creating a contest](/contests/set-up-contest) on Fermion is simple and flexible. This guide explains how to add questions to your contest, the available question types, and how to configure contest settings for a smooth participant experience.

<Info>
  Before you begin, make sure **Contests** are enabled under **Manage Features** in your instructor dashboard. This is required to create and run contests on Fermion. Learn how to enable features [here](/manage-settings/manage-features).
</Info>

## Adding questions to your contest

When building your contest, you can add different types of questions to assess participants in various ways. Fermion supports the following question types:

* **Interactive Coding Lab:** Real-time coding problems where participants write, run, and submit code in an interactive editor. Useful for practical programming assessments.
* **DSA Coding Lab:** Specialized coding questions focused on Data Structures and Algorithms. These problems are auto-graded and can include custom test cases.
* **Quizzes:** Multiple-choice or short-answer questions to test theoretical knowledge or concepts.

You can mix and match these question types within a single contest to create a comprehensive assessment.

### Steps to add questions and configure your contest

<Steps>
  <Step title="Navigate to contests">
    1. Go to your **Instructor dashboard → Contests**.
       ![Contests](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_agE8HY7g2C.plhuzx.png)
    2. Click **Create new contest** to start a new contest, or select an existing contest to edit its questions and settings.
       ![Access Contest](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_tML1dwAHoo.yqpiww.png)
  </Step>

  <Step title="Set up questions">
    1. Click on `Setup contest`
    2. Then, click on `Add item`
       ![setup-contest-questions](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_d9jwUaOOn1.datezo.png)
  </Step>

  <Step title="Add more items to the contest">
    By default, a quiz is added when you create an item / section in an empty contest. You can add more items to this contest by clicking on the `+` icon.
    ![add=item](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_CUkryurdZC.fsvetx.png)
    Or, you can also add multiple sections to the contest, which are shown to user / student in different sections.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_uy1vF16xgp.gdcdak.png)
    Then, you can choose from one of the 3 options :

    * DSA lab
    * Interactive lab
    * Quiz
      ![add-item](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_yzoLRmd6H0.pipnmr.png)
  </Step>

  <Step title="Link or create the labs">
    To attach coding labs, click on the `Attach coding lab` button.
    ![attachlab](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_yTv0P0Hamz.cxbkpm.png)
    Then, you can choose to either `Attach an existing lab` or `Create a new one`
    ![labs](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_DdALPsZ99c.adhpan.png)
  </Step>

  <Step title="Publish and share Your contest">
    Once your contest is ready:

    * Click **Publish** to make the contest live.
    * You can update the contest link, set it to **Unlisted** or **Draft** mode, and share the contest link with participants.

    <Info>
      You can also link your contest to a course or bundle, allowing enrolled students to participate automatically. Learn more about integrating contests with courses in the [Contests Introduction](/contests/introduction) documentation.
    </Info>
  </Step>
</Steps>

## Sectional timer for contests

You can set individual time limits for each section of your contest using sectional timers. This helps structure your contest more effectively and ensures participants manage their time within each section

### How to set sectional timers

<Steps>
  <Step title="Click on the timer icon next to the section name">
    Click on the timer icon beside the section name to set the sectional timer.<br />
    ![Timer Icon](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_iHvwzcDhvc.eijysm.png)
  </Step>

  <Step title="Enter the maximum number of minutes for the section">
    A dialog will appear where you can specify the max minutes allotted to this section. Enter the desired value.<br />
    ![Enter Section Minutes](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_XSVkFVLNcl.lenxwa.png)
  </Step>

  <Step title="Timer appears below the section name">
    Once set, the time limit will be shown beneath the section name and in the sidebar timer. This helps participants track their remaining time for each section.<br />
    ![Sectional Timer Shown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_NJ7t1s7n7F.cwwrqe.png)

    When the contest begins, users see the time remaining for each section in the sidebar, making it easy to manage their time.
    ![Section Timer in Sidebar](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_rUyxrVJrBC.iqkfar.png)
  </Step>
</Steps>

<Info>
  **Note:** The total time across all sections must **not** exceed the total contest duration. The platform will prompt you if you exceed the overall contest time limit.
</Info>


# Contests on Fermion
Source: https://docs.fermion.app/contests/introduction

Learn how to create, manage, and run coding contests and quizzes on Fermion, including attempt tracking and analytics.

## What is a Contest?

A **Contest** on Fermion is a competitive assessment or challenge that allows you to evaluate student skills in a timed, proctored environment. Contests can include coding problems, quizzes, or other types of assessments, and are designed to foster engagement, learning, and healthy competition among participants.

On Fermion, you can create and manage contests directly from your instructor dashboard. Contests can be used as standalone events, integrated into courses, or included in bundles to enhance your learning offerings.

Once you create a contest, Fermion handles participant registration, submission management, and real-time scoring. The [User attempts](/contests/introduction) page gives you a central place to track attempts, review submissions, and view analytics on participant performance.

<Info>Before you start, make sure **Contests** are enabled under **Manage Features** in your instructor dashboard. This allows you to create and run contests on Fermion. Learn how to enable features at Fermion [here](/manage-settings/manage-features)</Info>

## Key features

Fermion contests include:

* **Timed assessments:** Set time limits for the entire contest or for individual problems.
* **Attempt tracking:** Monitor participant attempts, view submission history, and analyze progress.
* **Automatic grading:** For coding problems and quizzes, Fermion can automatically evaluate submissions and provide instant feedback.
* **Leaderboard & analytics:** Track top performers, view detailed analytics, and export results for further analysis.
* **Flexible question types:** Support for coding questions, multiple-choice, and custom formats.
* **Secure environment:** Ensure fair play with built-in proctoring features like screen recording full attempt, recording tab changes, disable copy-pasting and recording the user via camera.

## Next steps

Continue reading to learn how to set up and manage contests on Fermion:

<Columns>
  <Card title="Creating a Contest" href="/contests/set-up-contest#creating-a-contest">
    Learn how to set up a contest and configure its settings.
    [Learn more](/contests/set-up-contest#creating-a-contest)
  </Card>
</Columns>


# Configuring a Contest
Source: https://docs.fermion.app/contests/set-up-contest

Step-by-step guide to creating and configuring coding contests and quizzes on Fermion, with details on settings, attempt tracking, and analytics.

Setting up your first contest on Fermion is straightforward. This guide will walk you through each step, from creating a new contest to configuring its settings and publishing it for participants. Fermion makes it easy to manage your contest, track attempts, and analyze results.

<Info>
  Before you begin, ensure that **Contests** are enabled under **Manage Features** in your instructor dashboard. This is required to create and run contests on Fermion. Learn how to enable features [here](/manage-settings/manage-features).
</Info>

## Creating a contest

Your contest page is where participants will view problems, submit solutions, and track their progress. A well-configured contest page helps ensure a smooth experience for both organizers and participants.

### Steps to set up a contest

<Steps>
  <Step title="Navigate to contests">
    1. Go to your **Instructor dashboard → Contests**.
       ![Contests](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_agE8HY7g2C.plhuzx.png)
    2. Click **Create new contest** to start a new contest, or select an existing contest to edit its settings.
       ![Access Contest](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_tML1dwAHoo.yqpiww.png)
  </Step>

  <Step title="Configure contest details">
    In the contest builder, fill in the essential details:

    * **Contest Name & Description:** Clearly state the contest’s purpose and add a shrt description.
    * **Banner Image:** Upload a banner to make your contest stand out.
      ![Contest Metadata](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_pDHSn6l9X2.nrvoyl.png)
  </Step>

  <Step title="Add instructions">
    Write clear instructions for participants. Then, add your contest problems, quizzes, or questions.
    ![Add instructions](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_C7iKH1bEyX.payfxu.png)
  </Step>

  <Step title="Set contest rules and proctoring">
    Click on `Configuration` to set up settings such as:

    * **Start and end time:** Schedule when the contest will be available.
    * **Time Limit:** Set a total duration or per-question time limits.
      -**Restrict re-attempts:** Set a total number of times users can retry this contest
      ![config1](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_uYSCHyJxSS.avmfex.png)
    * **Proctoring Options:** Enable features like screen recording, tab change detection, and camera monitoring to ensure fair play.

    You can also select an option where the contest auto-ends for a user when they violate any of the proctoring rules.
    ![Contest Settings](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_aUlofwfli7.dmtmrs.jpg)

    Once you are done configuring the contest, click on `Save changes`
  </Step>

  <Step title="Publish and share Your Contest">
    Once your contest is ready:

    * Click **Publish** to make the contest live.
    * You can update the contest link, set it to **Unlisted** or **Draft** mode, and share the contest link with participants.

    <Info>
      You can also link your contest to a course or bundle, allowing enrolled students to participate automatically. Learn more about integrating contests with courses in the [Contests Introduction](/contests/introduction) documentation.
    </Info>
  </Step>
</Steps>

***

## Contest access, pricing, and coupons

Contests can be free or paid, and you can control access just like other digital products on Fermion.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_PzQuOKjhHW.rivnjg.png)

You can set up a **[fixed pricing plan](/setup-pricing/fixed-pricing-plan)** for paid contests, or use a **[partial payment plan](/setup-pricing/setup-emi)** if you want to allow installment payments. You can also import pricing from other products.  For more information, see [Pricing FAQs](/setup-pricing/common-faqs).

## Contest settings & management

Manage your contest’s settings to control access and maintain organization.

**Enrollment Settings:**
Decide who can participate in your contest. By default, contests are open / visible to anyone that has access to your school.

You can change this by enabling `Manual enrollment`
![manual enroll](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Arc_qDKTwndvq3.kjwwuy.png)

<Tip>
  If the contest is linked to a course or bundle, enrolled users will automatically get access. Learn more about [Linking Contests to Courses](/contests/introduction).
</Tip>


# User Attempts
Source: https://docs.fermion.app/contests/user-attempts

Learn how users can start, attempt, and review contests in Fermion.

In Fermion, users can participate in programming contests and assessments. Each contest is timed, proctored, and provides detailed analytics of the user's performance. This guide explains the flow of a user attempt, from the instructions screen to the result report.

## Instructions screen

Before starting a contest, users are presented with an **Instructions Screen**. This screen provides all necessary details about the contest, including the duration, number of questions, and important guidelines.

The following details are also mentioned on the left pane of the contest.

* **Contest Name:** The name of the contest.
* **Test Duration:** Maximum time available for the student to finish the contest.
* **Question Count:** Number of questions inside the contest

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_yXIcg6Qq6G.iwqghq.png)

**Key Instructions:**

* This is a timed test. Ensure you are not interrupted during the contest, as the timer cannot be paused once started.
* Make sure you have a stable internet connection and a modern web browser.
* The attempt will be proctored and recorded. Avoid switching to other windows or moving your cursor out of the test window during the attempt.

These are predefined instructions set by Fermion. You can edit your own custom instructions by heading over to the contest landing page. Learn more about [custom instructions](/contests/set-up-contest#steps-to-set-up-a-contest).

Users can click **Continue** once they are ready to proceed.

***

## Section breakdown

After the instructions, users see a **Section Breakdown**, which provides an overview of all questions in the contest. This allows the user to understand the total number of questions and plan their approach.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_ojoSmwcnJB.wwfkyj.png)

***

## Start attempt: Terms and Conditions

Before beginning the contest, users must agree to the **Terms and Conditions**.

Typical agreements include:

1. Not copying code or answers from any source, including websites, LLMs like ChatGPT, books, or colleagues.
2. Not sharing the platform's or contest's copyrighted content.
3. Agreeing to the platform's Terms of Service and Privacy Policy.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_eDGUAAkSF9.soegbs.png)

Users must also enable **Fullscreen Mode** and allow access to their **camera and microphone** if proctoring is enabled.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_8mYenMevTs.yraget.png)

***

## Attempting questions

Once the contest starts:

* Users can view and attempt each question.
* If you have added multiple sections in the contest, you can see the questions, separated by sections as well. This feature helps organize complex contests with different question types or topics. For more information on adding sections, see [Contest Questions](/contests/contest-questions).
* The platform tracks time, user interactions, and proctoring data (if enabled) to ensure compliance.
* Users can submit answers as they complete each question or submit the full contest once done.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_sHlxPOHA5Z.nipziw.png)

***

## Result report

After submission, users can view their **Result Report**, which provides detailed feedback on their performance. The result report UI has been improved to offer clearer visualization of performance metrics and easier navigation through results.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_35dDzMzQQm.jbfcum.png)

**Report Sections:**

* **Final Score:** Total points achieved vs. total possible points.
* **Time Taken:** Duration spent completing the contest.
* **Accuracy:** Percentage of correct answers.
* **Proctoring Violations Summary:** Tracks violations such as:
  * Exiting fullscreen
  * Losing tab focus
  * Copying restrictions

Users can also scroll further and expand each question to see feedback.

## Contest results

After your contest ends (or while it is ongoing), instructors can review performance data, user attempts, and generate reports for analysis. This section explains how to navigate the contest results dashboard.

## Accessing user attempts by instructor

To view user attempts as an instructor, perform the following steps:

<Steps>
  <Step title="Open the product builder">
    Open the **Product Builder** for your contest you would like to check the results of.
  </Step>

  <Step title="Click on User attempts tab">
    Navigate to the **User Attempts** tab in the sidebar to access all the results and reports of the contest.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_ZMn8XfXT8b.stvdwa.png)
  </Step>
</Steps>

Here, instructors can see an overview of the contest:

### Contest Summary

The **Contest Summary** provides instructors with a quick overview of participant engagement and performance metrics.
Here, you can monitor the overall status of the contest, including how many users are **Total enrolled**, how many have
**Participated**, and the **Total attempts** submitted. Key performance indicators such as **Average score**, **Highest score**, **Lowest score**, and **Avg. completion time**
help you gauge overall difficulty and participant performance. The **Percentile score distribution (0–20%, 40–60%, 80–100%)**
gives a clear picture of how participants are performing relative to each other.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_IDeLu8ruFn.zgusgm.png)

<Tip>
  The contest summary updates in real-time as more participants submit their attempts.
</Tip>

***

### Viewing individual attempts

Instructors can access detailed information for each participant by switching to the **Individual Attempts** tab. Click on the **User attempts** tab to view responses for each participant.
Click on **See attempt report** to download the contest attempt report for that particular user. You can also access the user's profile from the same section by clicking **Open user profile** button.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_oiQu2hKbCk.cbkrrg.png)

<Note>
  You can filter or search for specific participants by their name or email if your contest has many users.
</Note>

***

### Downloading contest reports

To download reports:

1. Go to the **Exported reports** tab within your contest user attempts section.
2. Click on **Create a new export report**. The report will take a few moments to process and will be available to download.
3. Click **Download report** to export the contest results in a CSV format.
   ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_TM7UBDTmBo.rktojx.png)


# AI Lab Builder
Source: https://docs.fermion.app/creating-coding-labs/ai-lab-builder

Learn how to create coding labs using Fermion AI Agent builder

Fermion's AI Lab Builder allows you to quickly create interactive coding labs using AI assistance. This feature helps you generate lab content, instructions, and challenges automatically based on your requirements.

## Getting Started

<Steps>
  <Step title="Access the AI Lab Builder">
    To get started with the AI Lab Builder:

    1. Navigate to your **Dashboard**
    2. Go to **Coding labs** → **Labs** → **Interactive labs**
    3. Click on **Build using AI Agent**

    ![AI Lab Builder Access](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_oVn3asH5ln.plalkw.png)
  </Step>

  <Step title="Configure Your Lab">
    Once you've accessed the AI Lab Builder, you'll need to:

    1. **Enter a title** for your coding lab
    2. **Choose a language or framework** from the available options

    ![Lab Configuration](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_p0k7iUPsWi.drpolr.png)

    Once you've selected your preferred technology and entered a title, the AI Agent will help you generate the lab structure, including:

    * Initial project setup
    * Lab instructions
    * Coding challenges
    * Evaluation criteria

    The AI will create a complete, ready-to-use coding lab that you can further customize as needed.
  </Step>

  <Step title="Use the AI Agent Chat Window">
    After configuring your lab, use the **AI agent chat window on the left** to start building your lab. The AI agent can understand natural language instructions and automatically configure your lab by invoking various tool calls.

    ![AI Agent Chat Window](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_iwVWd91QM1.qlknlr.png)

    You can interact with the AI agent using natural language. For example, you can ask it to:

    * Create project files and folder structure
    * Install dependencies
    * Set up test cases
    * Configure the lab description
    * Generate evaluation scripts

    The AI agent will automatically use the appropriate tool calls to fulfill your requests.
  </Step>

  <Step title="Interact with the AI Agent">
    Interact with the AI agent by describing your requirements in natural language. The AI agent will process your instructions and automatically set up the lab for you, including:

    * Creating the necessary project files
    * Writing initial code templates
    * Configuring challenges
    * Updating lab instructions and descriptions

    ![AI Agent Interaction](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_aOpswNXqYB.tovkuc.png)

    Simply type your requirements in the chat window and wait for the AI agent to set up the lab. The agent will execute the necessary tool calls in the background and provide you with a summary once the lab is ready. You can then review the generated lab, test it, and make any additional adjustments as needed.
  </Step>

  <Step title="Verify the Generated Lab">
    After the AI agent has set up your lab, it's important to verify that all the generated data and code are correct. Review the following components and make any necessary adjustments before using the lab in your courses.
  </Step>
</Steps>

## Available Languages and Frameworks

The AI Lab Builder supports the following technologies:

<Columns>
  <Card title="HTML/CSS/JavaScript" icon="html5">
    Create web pages, style with CSS, and add interactivity with JavaScript.
  </Card>

  <Card title="React/Springboot (Java)" icon="react">
    Build robust backend services with React + Springboot.
  </Card>

  <Card title="Next.js" icon="https://img.icons8.com/?size=100&id=yUdJlcKanVbh&format=png&color=0EA5E9">
    Build fullstack React apps with Next.js <br /><span>(Coming soon)</span>
  </Card>

  <Card title="Node.js" icon="node-js">
    Create backend APIs and services with Node.js <br /><span>(Coming soon)</span>
  </Card>

  <Card title="Django (Python)" icon="python">
    Build web apps and APIs with Django and Python <br /><span>(Coming soon)</span>
  </Card>
</Columns>

## Available Tool Calls

The AI agent can invoke the following tool calls to build your lab:

<AccordionGroup>
  <Accordion title="update-coding-lab-title-and-description">
    Updates the lab's title and its Markdown description.

    **Parameters:**

    * `title` (string) - The title of the coding lab
    * `description` (string) - The Markdown description of the lab
  </Accordion>

  <Accordion title="update-coding-lab-test-cases-and-test-file">
    Defines or updates the array of challenge descriptions and the Puppeteer-based evaluation script.

    **Parameters:**

    * `testCases` (string\[]) - List of challenge texts in order
    * `testFileContent` (string) - Full content of the Node.js/Puppeteer test file
  </Accordion>

  <Accordion title="run-bash-command-inside-container">
    Executes an arbitrary bash command inside the sandbox (working directory: `/home/damner/code`). Useful for creating files, listing directories, installing dependencies, etc.

    **Parameters:**

    * `command` (string) - The bash command to execute
  </Accordion>
</AccordionGroup>

## Verification Checklist

After the AI agent has set up your lab, use this checklist to verify everything is correct:

<AccordionGroup>
  <Accordion title="Check the Challenges">
    Make sure the AI has generated the right set of challenges that align with your requirements. You can view the challenges in the **CHALLENGES** tab on the left sidebar. Verify that:

    * All required challenges are present
    * Challenge descriptions are clear and accurate
    * Challenges are in the correct order
    * Each challenge tests the intended functionality
  </Accordion>

  <Accordion title="Review Generated Code">
    Check the generated code files to ensure:

    * **Project structure** - Files and folders are organized correctly
    * **Code quality** - The initial code templates are appropriate for the lab
    * **Dependencies** - Required packages and libraries are properly installed
    * **File completeness** - All necessary files have been created
  </Accordion>

  <Accordion title="Test the Lab">
    Use the **Run Tests** button to verify that:

    * The lab environment boots correctly
    * All challenges can be evaluated properly
    * The evaluation script works as expected
    * Students can complete the challenges successfully
  </Accordion>

  <Accordion title="Make Adjustments">
    If you find any issues or want to make changes:

    * Continue chatting with the AI agent to request modifications
    * Manually edit files, challenges, or descriptions as needed
    * Test again to ensure everything works correctly
  </Accordion>
</AccordionGroup>

Once verified, your lab is ready to be used in your courses!


# Using .cdmrc
Source: https://docs.fermion.app/creating-coding-labs/cdmrc-file

Learn how to configure coding labs using the .cdmrc configuration file

The file `.cdmrc` is a very important file for your playgrounds. This is the configuration file for codedamn playgrounds that control how your playground behaves. This is written in YAML. You can [learn YAML syntax here](https://www.youtube.com/watch?v=motSWssLHCQ).

There are only a few key-value pairs you can specify in this file. They are documented here. Let's learn how you can work with `.cdmrc` with example configs.

## Creating Terminals

```yaml theme={null}
terminals: ['echo one', 'echo two', 'echo three']
```

The `terminals` key can be use to execute commands in the terminal instances. You can boot up to **6** terminals instances. The `terminals` array in the `.cdmrc` can only contain 6 elements in them.

The above config will create 3 terminals and execute the commands `echo one`, `echo two` and `echo three` in them. The config above will start three terminals as soon as your playground boots. Note that these commands run only once the playground is booted. This means that if you invite collaborators to your playground, and you're already on that same playground (that already has executed these commands), they will **not** run again.

Note that the terminals will not execute in the same order as given in the array, the order of the terminal tabs is based on the execution time of the commands. The terminal that executes the command first will be the first tab, and so on.

## Default Files

```yaml theme={null}
tabs: ['src/index.html', 'src/folder/script1.js', 'README.md']
```

The `tabs` field in the `.cdmrc` is an array of strings. Once specified, whenever your playground boots for the first time - it would open the mentioned files by default in the Monaco editor.

This is for a good UX when users don't know what should be a good entry point for the project.

We at codedamn do this on our codelabs and some default playground repos. You can customize this behavior or disable it completely by passing an empty array `[]` or just removing the key altogether.

You can also optionally specify a line number and column number separated by a `#` symbol. This will automatically place the cursor at the specified position. Here's how a modified version could look like:

```yaml theme={null}
tabs: ['src/index.html#22:10', 'src/folder/script1.js#2:55', 'README.md']
```

The config above will open `index.html` file at line number 22 and column number 10 the first time user opens it. Similarly, for `script1.js` file above, it'll open at line number 2 and column number 55.

## Playground view

```yaml theme={null}
playground-view: terminal-editor-browser
```

There are three possible views for playground you can specify in this configuration:

* `terminal-editor-browser`: This view includes terminal, editor and browser preview. It is the best and recommended view if you intend to use a frontend web server to display output.
* `terminal-editor`: This view includes a terminal and an editor only. It is good for programming where no web server is involved. For example, writing a sorting algorithm in C++ may not need a web server output.
* `terminal-browser`: This view includes only the terminal and browser. You can combine it with `browser-link` too.

## Run button

```yaml theme={null}
run-button: node $$file
```

The `run-button` command in a playground does two things:

* It makes a new button saying "Run Code" visible on your playground.
* When you click on that "Run Code" button - it executes that command in the first terminal. However, we **automatically** run a **CTRL + C** sequence as well to terminate any previously running program. Therefore, anything running in the foreground on your first terminal would get terminated.

This is especially useful when you're working with, say, a program that requires you to run the same command over and over again. You can open a C++ playground on codedamn and configure the command as `gcc script.c -o script && ./script` and every time you click on `Run Code` button, it'll execute this script.

Another important thing to note here is the `$$file` syntax. If you'd like to run a command dynamically on the focused tab/active tab, you can specify `$$file` and we would run your command after replacing `$$file` it with the path to the file you have currently opened inside your Monaco editor on codedamn.

For example, if you're on `src/index.js` file and your `run-button` command is `node $$file`, then when you click on "Run Code" button, we would run `node src/index.js`. If you change file and click on the button again, we'll update the path again before running.

## Browser Link

```
browser-link: https://codedamn.com
```

By default, we open `https://<whatever-host-is-assigned-to-you>.codedamn.app:1337` in the iframe browser preview on the right. However, you can override the webpage opened on the right using the command shown above.

Note that because we use `iframe` to embed the window, it is entirely possible that a variety of URLs might not work due to `x-frame-options` set to `sameorigin` or `deny`. [Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options).

## Conclusion

Here's a dummy config file that uses all the options we have currently:

```yaml theme={null}
# terminals
terminals:
    [
        'cd client && yarn && yarn start',
        'cd server && yarn && yarn dev',
        'echo "We''re ready"',
    ]
# other config
tabs: ['README.md']
run-button: clear && node $$file
browser-link: https://wikipedia.org
```


# Embed an Interactive Lab
Source: https://docs.fermion.app/creating-coding-labs/embedding-lab

Step-by-step guide to embedding a coding lab inside your course or website using Fermion’s lab embed tools.

This article discusses integrating an IDE and including evaluative coding labs under your organization. Here are some key points before we jump in:

## What is a coding lab?

A coding lab is an immersive experience where users learn by doing. We support every popular technology. Here’s a non-exhaustive (but popular) list:

* Node.js
* Bun
* Python
* Rust
* C/C++
* Java
* C#
* Solidity
* Golang
* PHP
* Swift
* SQLite
* Every frontend framework

Note that once a compiler/programming language is supported, every associated framework with it is supported automatically.

For example, with Java, we automatically support Springboot. With Python, we automatically support Django, flask, etc. With Node.js, we automatically support Express, etc., and so on.

On top of this, you can add evaluation inside every lab. This means that you can **check and grade** the work done by user automatically, just like how you would do when working with them 1:1.

Here’s how a coding lab environment looks like:

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/07/20114507/Screenshot-2024-08-20-at-11%E2%80%AF.44.57%402x-1024x580.png)

## How do you create a coding lab?

Complete documentation has been laid out [here](/creating-coding-labs/what-are-coding-labs), where you can follow the instructions according to the technology you want to use, and create coding labs.

## How to embed a coding lab from Fermion?

Before starting the embed process, you need two things:

1. A school on Fermion
2. Fermion API key

[Contact support](https://codedamn.com/contact) to get both of these things set up for you.

After creating a lab from your Fermion Dashboard, you will get a unique identifier of the lab called `labId`. Here’s what it would look like:

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/07/20114958/Screenshot-2024-08-20-at-11%E2%80%AF.49.49.png)

Clicking the `Embed coding lab` button would give you access to the `labId` and other important parameters.

On any page in which you wish to let the user attempt the lab, you need to embed an iframe as follows:

```xml theme={null}
<iframe
	width="1280"
	height="720"
	src="https://acme2.fermion.app/embed/lab?token=EMBED_TOKEN_HERE"
	title="Coding Lab"
	frameborder="0"
	allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope;
	picture-in-picture; web-share"
	referrerpolicy="strict-origin-when-cross-origin"
	allowfullscreen>
</iframe>
```

Here, the `EMBED_URL` needs to be securely generated on your backend as follows:

1. The embed URL will always contain the following part: [`https://example.fermion.app/embed/lab?token=`.](https://example.fermion.app/embed/lab?token=.)
2. After this, you need to generate a JWT (JSON Web Token) containing the following claims:The JWT token must be signed with your Fermion API Key. Example JWT: [here](https://jwt.io/#debugger-io?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJsYWJJZCI6ImFiY2QiLCJ1c2VySWQiOiJ4eXoiLCJpYXQiOjE1MTYyMzkwMjJ9.9SKcAU52Qad6MERnzy1kF4Y0A3SoAWuGfpmE97JDYOo)
   1. `labId` (String) – This is the unique identifier of the lab as mentioned above.
   2. `userId` (String) – This is a string that you have stored in your database that can uniquely identify a given user. You have to ensure that you store this identifier properly in your database and reuse it every time a user tries to access any lab.
3. Append this generated JWT token to the end to get the final embed URL.

Example JavaScript code to generate `EMBED_URL` securely on your backend server:

This example uses the [jsonwebtoken package](https://www.npmjs.com/package/jsonwebtoken) to generate a JWT Token.

```js theme={null}
import jwt from 'jsonwebtoken'

const jwtToken = jwt.sign(
	{
		labId: '66a9202ab1458d00083ff520',
		userId: '<enter a user ID here unique to every user>',

		// optionally specify more properties
		playgroundOptions: {
			// change this to false to disallow copy-paste
			isCodeCopyPasteAllowed: true,

			// change this to true to hide logo
			shouldHideLogo: true,

			// change this to true to hide the test output logs section in the editor.
			shouldHideTestOutputLogs: false,

			// change this to `true` to render the embedded coding lab in a read-only mode
			isReadOnly: false,

			// change this to true and supply a lab ID to boot the new lab filesystem from the older lab (documented below)
			overrideDefaultFilesystemForLab: {
				isEnabled: false,
			},
		},
	},
	'FERMION_API_KEY',
	{ expiresIn: '1h' }
)

const EMBED_URL =
	'https://example.fermion.app/embed/lab?token=' +
	encodeURIComponent(jwtToken)
```

## Playground options

In the JWT creation above, you can see there are many options you can use to customize the behaviour. Let's break down what each option does here.

### isCodeCopyPasteAllowed

Enabling this will restrict people to paste directly in the editor. Use this if you do not want people to be able to paste code inside editor using mouse or keyboard shortcuts

### shouldHideLogo

By default, when you embed the lab, your school logo will be visible on top left of the IDE interface. If you enable this the logo will be hidden.

### shouldHideTestOutputLogs

By default, the output logs of the lab's challenges will be shown in the embedded IDE after users run their code. If you set `shouldHideTestOutputLogs` to `true`, the test output logs section will be hidden from the user's view.

**Example:**

```js theme={null}
playgroundOptions: {
    shouldHideTestOutputLogs: true,
}
```

### isReadOnly

Setting `isReadOnly` to `true` will render the embedded coding lab in a read-only mode. This means users can view the lab and its content, but will not be able to edit files. This is useful if you want to showcase the lab without allowing further interaction.

**Example:**

```js theme={null}
playgroundOptions: {
    isReadOnly: true,
}
```

### overrideDefaultFilesystemForLab

`overrideDefaultFilesystemForLab` option can be used to configure how the coding lab filesystem will start. The accepted schema for this, if not null, is the following:

```ts theme={null}
type Schema =
	| {
			isEnabled: false
	  }
	| {
			labId: string
			isEnabled: true
			type: 'other-lab-id'
	  }
```

#### Case 1: isEnabled = false

If you do not pass this option, or pass it as `isEnabled` = `false` then the default behavior is as follows:

* On the very first time the user starts the lab, since there is no previous work for the lab, it will start the filesystem with the GitHub repository (and branch) you gave while setting up the lab initially.
* When the user comes back to the lab in future, the filesystem is restored from a snapshot of their past work, and not GitHub repository you supplied initially.

#### Case 2: isEnabled = true

If you enable this option, you must specify a `type`. The only possible option today is `other-lab-id`. Pass the `labId` in the same object to be the `labId` which you would like to make the starting point for user for this lab.

Let's say the lab you're creating this JWT token for has an ID of `X` and the `labId` you passed in `overrideDefaultFilesystemForLab` has ID `Y`.

* Whenever user starts lab `X` with your token supplied, system will check if there is a past work snapshot for the given user that exists for the lab `X`.
* In case it does not (i.e. when the user starts the lab for the first time), system will check if there is a past work snapshot for the given user that exists for the lab `Y`.
* If work exists for `Y`, system will copy the filesystem to lab `X` and user will start the lab `X` with the filesystem of lab `Y`.
* If work does not exist for `Y`, system will boot the filesystem from the GitHub repository (and branch) you gave while setting up lab `X`.

> **Note:** After creating a new lab or updating its filesystem programmatically (for example, via API or automation), please allow up to **2 minutes** before starting the lab. This delay ensures that all lab files and environment are fully synchronized and ready for use. Starting the lab immediately after creation may result in incorrect or outdated file contents(when override is enabled).

## How can I access lab results?

### Public API

We have an OpenAPI-spec compliant public API you can use, once you have access to FERMION\_API\_KEY. You can use this API to query multiple data points for your organization.

Please check the [API documentation here](https://api.fermion.app).

### window\.postMessage results

Alongside this, when you embed the lab on your domain, we will also emit events in real time through `window.postMessage` API. You can read more about [`window.postMessage` API here](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage).

Note that you must not fully rely on events emitted by `window.postMessage` you because of security reasons. Please do a server-side validation with our real API endpoint to be sure of the final result. You can use messages from `window.postMessage` to optimistically display results, however, since it is a client-side API, it is possible to hijack the event data by the untrusted user.

You can listen to every postMessage like this:

```js theme={null}
window.addEventListener('message', (event) => {
	const payload = event.data

	if (
		payload == null ||
		typeof payload !== 'object' ||
		!('eventType' in payload)
	) {
		// not from fermion
		return
	}

	if (payload.eventType === 'fermion-lab-run-finished') {
		// do further processing
	}
})
```

We also recommend processing `event.data` with zod if you can. Our schemas are strictly typed and are zod-parseable.

Here are the events we emit through `window.postMessage` API:

#### fermion-lab-run-finished

We emit the following object on every lab run finished. Here’s a TypeScript type for this event:

```js theme={null}
type Event = {
	eventType: 'fermion-lab-run-finished',
	data:
		| {
				status: 'ok',
				totalChallengesCount: number,
				passedChallengesCount: number,
				failedChallengesCount: number,
		  }
		| {
				status: 'error',
				errorMessage: string,
		  },
}
```

To check if a user’s lab run was successful, you can check if `totalChallengesCount` is equal to `passedChallengesCount` and take any action in your LMS frontend code accordingly.

You can query for this data through our public API as well for better guarantees of security.

## Have a doubt?

In case something doesn’t work right, or you have any doubt, please feel free to reach out to us at [support@codedamn.com](mailto:support@codedamn.com) with your query, we’d be happy to resolve it at the earliest.


#  HTML/CSS Labs
Source: https://docs.fermion.app/creating-coding-labs/technologies/html-css

Create interactive front-end labs for learners to experiment with live HTML and CSS code directly in the browser.

Coding labs is a powerful feature of Fermion. Using coding labs in your platform, you can increase user retention, provide hands-on experience to them, and make them learn-by-doing.

Let's take a look at how you can setup a HTML/CSS/JS interactive coding lab in this guide.

<iframe />

## Step 1 - Creating the Lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab Instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults section include how your lab environment boots. It is one of the most important parts because a wrong default environment might confuse your students. Therefore it is important to set it up properly.

<Info>
  We recommend forking this repository: [HTML playground
  starter](https://github.com/codedamn-classrooms/html-playground-starter).
</Info>

The repository also includes a `.cdmrc` file, a critical configuration file for Fermion labs. Familiarize yourself with the [.cdmrc guide](/creating-coding-labs/cdmrc-file) to understand how it works before proceeding.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-2024-11-17-3%E2%80%AF-31-53%402x.kzdbiv.png)

## Step 4 - Evaluation Script

Evaluation script is actually what runs when the user on the playground clicks on "Run Tests" button.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/lab-run-tests.exllxt.png)
![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000001%402x.ywpfjc.png)

Since we have already written a pure evaluation script that runs and finally writes the JSON result to the `UNIT_TEST_OUTPUT_FILE` environment, all we have to do is trigger that script via Node.js.

The full path of the script is made available at run-time with another environment variable called `TEST_FILE_NAME`. Therefore, all we have to do is write the following in the evaluation script area:

```sh theme={null}
#!/bin/bash
set -e 1

# create a folder for test
mkdir -p /home/damner/code/.labtests

# move to the folder
cd /home/damner/code/.labtests

# move test file here
mv $TEST_FILE_NAME nodecheck.spec.js

# mark this as module
cat > package.json << EOF
{
    "type": "module"
}
EOF

# write playwright config file
cat > playwright.config.ts << EOF
import { defineConfig, devices } from '@playwright/test'
import puppeteer from 'puppeteer'

export default defineConfig({
	timeout: 10_000,
	maxFailures: 0,
	testDir: '.',
	fullyParallel: false,
	forbidOnly: true,
	retries: 0,
	workers: 1,

	// Reporter to use
	reporter: [['list'], ['json', { outputFile: './report.json' }]],

	use: {
		baseURL: 'http://localhost:1337/',
		trace: 'off',
		launchOptions: {
			headless: true,
			executablePath: puppeteer.executablePath(),
			chromiumSandbox: false
		}
	},

	projects: [
		{
			name: 'chromium',
			use: { ...devices['Desktop Chrome'] }
		}
	]
})
EOF

# `puppeteer` is installed via NPM in playgrounds. Use preinstalled dependency
npm link puppeteer
bun install @playwright/test@1.40.1 playwright@1.40.1

bunx playwright test || true

# process results file
cat > process-results.js << EOF
import fs from 'fs'
const payload = JSON.parse(fs.readFileSync('./report.json', 'utf-8'))
const answers = payload.suites[0].suites[0].specs.map(spec => spec.ok === true && spec.tests.every(t => t.status === 'expected'))
fs.writeFileSync(process.env.UNIT_TEST_OUTPUT_FILE, JSON.stringify(answers))
EOF

node process-results.js

```

This will make sure we run the full Node.js script and write the results properly for the playground IDE to read. It would look like the following:

**Note:** You can setup a full testing environment in this block of evaluation script (installing more packages, etc. if you want). However, your test file will be timed out **after 60 seconds**. Therefore, make sure, all of your testing can happen within 60 seconds.

## Step 5 - Test file

In the same `Evaluation` tab, you'll see another section called "Custom test file". You can use this test file to add custom code for testing user work.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000002%402x.mhhqir.png)

When you click on it, a new window will open. This is a test file area.

You can write anything here. Whatever script you write here, can be executed from the `Test command to run section` inside the evaluation tab we were in earlier.

The point of having a file like this to provide you with a place where you can write your evaluation script.

**For HTML/CSS labs, you can use the default test file for playwright:**

```js theme={null}
import { expect, test } from '@playwright/test'

test.describe.serial('Test', () => {
	test.beforeEach(async ({ page }, testInfo) => {
		console.log(`Running ${testInfo.title}`)
		await page.goto('/')
	})

	test('Stylesheet is linked', async ({ page }) => {
		const linkElement = page.locator('link[rel="stylesheet"]')
		expect(linkElement).toBeDefined()
		expect(await linkElement.getAttribute('href')).toEqual('style.css')
	})
})
```

This completes your evaluation script for the lab. Your lab is now almost ready for users.

## Step 6 - Add challenges

Finally, in the UI below, add friendly name of challenges that must be visible to the user. Note that the order of challenges is important here and must match the boolean array you write using the bash script + test file above.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000003%402x.bedrfe.png)


# Java Labs with JUnit
Source: https://docs.fermion.app/creating-coding-labs/technologies/java

Set up Java labs using JUnit for testing learners’ code submissions and validating results in real-time.

**Coding labs** are a powerful feature of Fermion. By integrating coding labs into your platform, you can enhance user retention, provide hands-on experience, and encourage a learn-by-doing approach.

This guide walks you through setting up a Java interactive coding lab.

## Step 1 - Creating the Lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab Instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults define the initial environment setup for the lab. It is crucial to configure this correctly to avoid confusing students.

For Java labs, the playground must initialize a valid Java project.

<Info>
  For Java playground, we recommend you to fork the following repository and
  use it as a starter template: [Java playground starter -
  codedamn](https://github.com/codedamn-classrooms/java-starter-playground)
</Info>

The repository also includes a `.cdmrc` file, a critical configuration file for Fermion labs. Familiarize yourself with the [.cdmrc guide](/creating-coding-labs/cdmrc-file) to understand how it works before proceeding.

## Step 4 - Evaluation Script

Evaluation script is actually what runs when the user on the codedamn playground clicks on "Run Tests" button.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/lab-run-tests.exllxt.png)
![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000001%402x.ywpfjc.png)

Since we will write a script that runs as a JUint test utility, all we have to do is trigger that script via Java + JUnit and write it to proper file `$UNIT_TEST_OUTPUT_FILE` for the UI to show the results.

```sh theme={null}
#!/bin/bash
set -e 1

# Compile user code
cd /home/damner/code
javac -cp . *.java

# setup test env
mkdir -p /home/damner/.labtests
cd /home/damner/.labtests
mv $TEST_FILE_NAME TestFile.java

# Download the junit5main.jar binary if not present
[ -e "junit5main.jar" ] || curl https://raw.githubusercontent.com/codedamn-classrooms/java-junit-files/main/junit5main.jar -o junit5main.jar

# Compile test file
javac -cp .:junit5main.jar TestFile.java

# Run the test file
java -jar junit5main.jar -cp .:/home/damner/code --select-class TestFile --reports-dir . || true

# Convert TEST-junit-jupiter.xml to JSON
yarn add xml2js
cat > process-result.js << EOF
const fs = require('fs')
const xmlFile = fs.readFileSync('./TEST-junit-jupiter.xml', 'utf8')
const { parseString } = require('xml2js')
parseString(xmlFile, (err, data) => {
    const results = []
    console.log(data.testsuite.testcase[0])
    for (let i = 0; i < data.testsuite.testcase.length; i++) {
        results.push(!data.testsuite.testcase[i].failure)
    }

    fs.writeFileSync(process.env.UNIT_TEST_OUTPUT_FILE, JSON.stringify(results))
})
EOF

# Run the node script to write results to playground UI
node process-result.js
```

This will make sure we run the full Java script and write the results properly for the playground IDE to read.

Let us understand what exactly is happening here:

* We first of all, compile all the user code by going to `/home/damner/code` directory and running `javac -cp . *.java`. This would compile all files. If you want to compile your user code in a different way, you can do it here.
* Next, we setup a temporary folder outside of user working space to download JUnit.
* JUnit jar binary would be downloaded only once. On subsequent runs, it would be reused.
* We then compile the `TestFile.java` (the JUnit code that we wrote in the full JUnit testing script above) with `junit5main.jar` being in the classpath.
* Finally, we run the `TestFile` class using `--select-class TestFile` (remember, this is the same class name of the JUnit test script as we wrote above in Test File section).
* We also add the user code in the classpath here itself so that we can import it directly in the test file (as we do).
* Finally, the `--reports-dir` flag outputs the result in the same directory which then we read with a simple Node.js script.
* JUnit outputs the results in XML. We use a simple `xml2js` parser to convert this into a JS object, and then convert the results into a boolean JSON array. We write this array inside `$UNIT_TEST_OUTPUT_FILE` which is then read by the playground and challenges are marked as passed or failed.

**Note:** You can setup a full testing environment in this block of evaluation script (installing more packages, etc. if you want). However, your test file will be timed out **after 30 seconds**. Therefore, make sure, all of your testing can happen within 30 seconds.

## Step 5 - Test File

Once you save the lab, you will see a button named `Edit Test File` in the `Evaluation` tab. Click on it.

When you click on it, a new window will open. This is a test file area.

You can write anything here. Whatever script you write here, can be executed from the `Test command to run section` inside the evaluation tab we were in earlier.

The point of having a file like this to provide you with a place where you can write your evaluation script.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000002%402x.mhhqir.png)

The moment you select the Java (JUint), the following code should appear in your editor:

```java theme={null}

import static org.junit.jupiter.api.Assertions.*;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.PrintStream;

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Method;


@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class TestFile {

    @BeforeAll
    public static void setupStuff() { // Runs before each test

    }

    @AfterAll
    public static void doCleanup() { // Runs after each test case

    }

    @Test
    @Order(1)
    public void test1() {
        try {
            Class classNameToTest = Class.forName("<Class Name Here>");
            Method methodToTest = classNameToTest.getMethod("< Method Name Here >"); // Optional: Add parameter types as second argument here

            var returnedOutput = methodToTest.invoke(null, null); // Give arguments as an array in 2nd parameter

            assertTrue(true); // Check for the expected output

        } catch(Exception e) {
            fail();
        }
    }
}
```

Let us understand what is happening here exactly:

* Remember that we can code anything in this file and then execute it later. In this example, we're writing a JUnit test in Java.
* With Java testing, it is possible that the user doesn't create methods or classes that you need to test. This might result in your whole test file to crash **if** you try to import it globally at the top.
* Therefore, we **recommend** to use Reflection API in Java to test everything. This allows you to strictly pass/fail tests even if the methods/classes don't exist. Otherwise, your boilerplate code would always need to have empty definitions and all classes pre-made.
* Reflection API might look very verbose in syntax but is fairly straightforward to implement once you understand the basics. You should learn about how to work with Reflection API in Java here: [Reflection API docs](https://javapapers.com/core-java/java-reflection-cheat-sheet/)
* Also note that the tests here are run in order through `@TestMethodOrder(MethodOrderer.OrderAnnotation.class)` and `@Order(1)` decorators. This is important if you want to map the results of these tests (passed/failed) correctly with the tests you added in challenges tab earlier.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/playground-tests.geugve.png)

* Let's say your tests results from up is PASS, FAIL, PASS, PASS. Then, the following would be the output on playground:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/playground-tests-2.tmstkq.png)

* **Note:** If your test suite contain less tests than challenges added back in the UI, the "extra" UI challenges would automatically stay as "false". If you add more challenges in test file, the results would be ignored. Therefore, it is **important** that the number of tests you write in the testing class is same as the number of challenges you added in the challenges UI.

This completes your evaluation script for the lab. Your lab is now almost ready for users.

### Reading the output from stdout

There are situations when you want to validate the output that is being printed on the terminal. For example, If you ask the user to write a simple Java code that prints 'Hello World', and you want to test if the user was able to print it correct or not, in this case you can easily compare the terminals output by the expected output using the `ByteArrayOutputStream`.

In your test() method, you can use the `out.toString()` method from the `out` object declared at the class level to read the output from the terminal and finally do a `assertEquals()` to compare the output.

Sample Code to check `Hello World` program:

```java theme={null}
import static org.junit.jupiter.api.Assertions.*;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.PrintStream;

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Method;


@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class TestFile {

    // IO Streams
    private static final  ByteArrayOutputStream out = new ByteArrayOutputStream();
    private static final ByteArrayOutputStream err = new ByteArrayOutputStream();
    private static ByteArrayInputStream inputStream;

    // Backup Streams
    private static final PrintStream originalOut = System.out;
    private static final PrintStream originalErr = System.err;
    private static final InputStream originalInput = System.in;


    @BeforeAll
    public static void setStreams() { // Override all the streams to our custom IO streams
        System.setOut(new PrintStream(out));
        System.setErr(new PrintStream(err));
    }

    @AfterAll
    public static void restoreInitialStreams() { // Restores all the streams to its original backups
        System.setOut(originalOut);
        System.setErr(originalErr);
        System.setIn(originalInput);
    }


    @Test
    @Order(1)
    public void test1() {
        try {
            Class classNameToTest = Class.forName("<Class Name Here>");
            Method methodToTest = classNameToTest.getMethod("< Method Name Here >"); // Optional: Add parameter types as second argument here

            var returnedOutput = methodToTest.invoke(null, null); // Give arguments as an array in 2nd parameter

            String outputFromConsole = out.toString(); // Reads the output from the terminal

            assertTrue(true); // Check for the expected output

        } catch(Exception e) {
            fail();
        }
    }
}
```


# Node.js Labs
Source: https://docs.fermion.app/creating-coding-labs/technologies/node

Learn how to build interactive coding labs with Node.js

Coding labs is a powerful feature of Fermion. Using coding labs in your platform, you can increase user retention, provide hands-on experience to them, and make them learn-by-doing.

Let's take a look at how you can setup a Node.js interactive coding lab in this guide.

<iframe />

## Step 1 - Creating the Lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab Instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults section include how your lab environment boots. It is one of the most important parts because a wrong default environment might confuse your students. Therefore it is important to set it up properly.

<Info>
  We recommend forking this repository: [Node.js playground
  starter](https://github.com/codedamn-classrooms/node-playground-starter).
</Info>

The repository also includes a `.cdmrc` file, a critical configuration file for Fermion labs. Familiarize yourself with the [.cdmrc guide](/creating-coding-labs/cdmrc-file) to understand how it works before proceeding.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-2024-11-17-3%E2%80%AF-31-53%402x.kzdbiv.png)

## Step 4 - Evaluation Script

Evaluation script is actually what runs when the user on the playground clicks on "Run Tests" button.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/lab-run-tests.exllxt.png)
![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000001%402x.ywpfjc.png)

Since we're going to test this lab using Vitest, we'll setup the Vitest testing environment. This is what your evaluation script would look like:

```sh theme={null}
#!/bin/bash
set -e 1

# Install vitest and testing util
cd /home/damner/code
bun add vitest@0.32.2 jsdom@22.1.0 @testing-library/jest-dom@5.16.5 --dev
mkdir -p /home/damner/code/.labtests

# Move test file
mv $TEST_FILE_NAME /home/damner/code/.labtests/nodecheck.test.js

# setup file
cat > /home/damner/code/.labtests/setup.js << EOF
import '@testing-library/jest-dom'
EOF

# vitest config file
cat > /home/damner/code/.labtests/config.js << EOF
import { defineConfig } from 'vite'

// https://vitejs.dev/config/
export default defineConfig({
	plugins: [],
    test: {
        globals: true,
		environment: 'jsdom',
		setupFiles: '/home/damner/code/.labtests/setup.js',
    }
})
EOF

# process.js file
cat > /home/damner/code/.labtests/process.js << EOF
import fs from 'node:fs'
const payload = JSON.parse(fs.readFileSync('./payload.json', 'utf8'))
const answers = payload.testResults[0].assertionResults.map(test => test.status === 'passed')

fs.writeFileSync(process.env.UNIT_TEST_OUTPUT_FILE, JSON.stringify(answers))
EOF

# package.json
cat > /home/damner/code/.labtests/package.json << EOF
{
    "type": "module"
}
EOF

# run test
(bun vitest run --config=/home/damner/code/.labtests/config.js --threads=false --reporter=json --outputFile=/home/damner/code/.labtests/payload.json || true)  | tee /home/damner/code/.labtests/evaluationscript.log

# Write results to UNIT_TEST_OUTPUT_FILE to communicate to frontend
cd /home/damner/code/.labtests
node process.js
```

This will make sure we run the full Node.js script and write the results properly for the playground IDE to read. It would look like the following:

**Note:** You can setup a full testing environment in this block of evaluation script (installing more packages, etc. if you want). However, your test file will be timed out **after 60 seconds**. Therefore, make sure, all of your testing can happen within 60 seconds.

## Step 5 - Test file

In the same `Evaluation` tab, you'll see another section called "Custom test file". You can use this test file to add custom code for testing user work.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000002%402x.mhhqir.png)

When you click on it, a new window will open. This is a test file area.

You can write anything here. Whatever script you write here, can be executed from the `Test command to run section` inside the evaluation tab we were in earlier.

The point of having a file like this to provide you with a place where you can write your evaluation script.

**For Node.js labs tested with Vitest, you can use the default test file:**

```js theme={null}
describe('Test runner suite', () => {
	test('Variable should be exported', async () => {
		const userVariable = await import('/home/damner/code/index.js').then(
			(t) => t.default
		)

		expect(typeof userVariable === 'undefined').to.be.false
	})

	test('Variable should have correct value', async () => {
		const userVariable = await import('/home/damner/code/index.js').then(
			(t) => t.default
		)
		expect(userVariable === 'Hello World').to.be.true
	})
})
```

This completes your evaluation script for the lab. Your lab is now almost ready for users.

## Step 6 - Add challenges

Finally, in the UI below, add friendly name of challenges that must be visible to the user. Note that the order of challenges is important here and must match the boolean array you write using the bash script + test file above.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000003%402x.bedrfe.png)


# Python lab with Pytest
Source: https://docs.fermion.app/creating-coding-labs/technologies/python

Develop interactive Python environments powered by Pytest for quick code execution

Coding labs is a powerful feature of Fermion. Using coding labs in your platform, you can increase user retention, provide hands-on experience to them, and make them learn-by-doing.

Let's take a look at how you can setup a Python interactive coding lab in this guide.

## Step 1 - Creating lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults section include how your lab environment boots. It is one of the most important parts because a wrong default environment might confuse your students. Therefore it is important to set it up properly.

When a playground boots, it can setup a filesystem for user by default. You can specify what the starting files could be, by specifying a git repository and a branch name:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-2024-11-17-3%E2%80%AF-31-53%402x.kzdbiv.png)

You will find a `.cdmrc` file in the repository given to you above. It is highly recommend, at this point, that you go through the [.cdmrc guide and how to use .cdmrc in playgrounds](/creating-coding-labs/cdmrc-file) to understand what `.cdmrc` file exactly is. Once you understand how to work with `.cdmrc` come back to this area.

## Step 4 - Evaluation script

Evaluation script is actually what runs when the user on the codedamn playground clicks on "Run Tests" button.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/lab-run-tests.exllxt.png)
![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000001%402x.ywpfjc.png)

Remember that we're using the Pytest utility in this lab to test.

Therefore, your testing script would look like as follows:

```sh theme={null}
#!/bin/bash
set -e 1

mkdir -p /home/damner/code/.labtests

mv $TEST_FILE_NAME /home/damner/code/.labtests/user-test-code.py
echo "" > /home/damner/code/.labtests/__init__.py

# Install pytest
pip3 install pytest pytest-json-report

# run test
cd /home/damner/code/.labtests
pytest --json-report user-test-code.py || true

# process results file
cat > processPythonResults.js << EOF
const payload = require('./.report.json')
const answers = payload.tests.map(test => test.outcome === 'passed')
require('fs').writeFileSync(process.env.UNIT_TEST_OUTPUT_FILE, JSON.stringify(answers))
EOF



# Write results to UNIT_TEST_OUTPUT_FILE to communicate to frontend
node /home/damner/code/.labtests/processPythonResults.js
```

You might need to have a little understanding of bash scripting. Let us understand how the evaluation bash script is working:

* With `set -e 1` we effectively say that the script should stop on any errors
* You can install additional packages here if you want. They would only be installed the first time user runs the test. On subsequent runs, it can reuse the installed packages (since they are not removed at the end of testing)
* Then we create a `.labtests` folder inside of the `/home/damner/code` user code directory. Note that `.labtests` is a special folder that can be used to place your test code. This folder will not be visible in the file explorer user sees, and the files placed in this folder are not "backed up to cloud" for user.
* We move the test file you wrote earlier (in last step) to `/home/damner/code/.labtests/pytest.py`.
* We then create another setup file `/home/damner/code/.labtests/processPythonResults.js`. This is because we need to parse the results outputted by the Python testing utility to reflect it on the playgrounds. You may as well create this file in python (reading the JSON report and outputting a boolean array in a file stored in env `$UNIT_TEST_OUTPUT_FILE`)
* This is important because on the playground page, the way challenges work, is that they get green or red based on a JSON boolean array written inside the file in environment variable: `$UNIT_TEST_OUTPUT_FILE`
* For example, once the test run succeeds, and if you write `[true,false,true,true]` inside `$UNIT_TEST_OUTPUT_FILE`, it would reflect as PASS, FAIL, PASS, PASS for 4 challenges available inside playground UI (as shown below)

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/playground-tests-2.tmstkq.png)

* Then we run the actual test using `python3 -m pytest` command, specifying the output as JSON (read by `processPythonResults.js`) and in a single thread (as we want ordered results).

* Finally we run the `processPythonResults.js` file that writes the correct JSON boolean array on `$UNIT_TEST_OUTPUT_FILE` which is then read by the playground UI and marks the lab challenges as pass or fail.

**Note:** You can setup a full testing environment in this block of evaluation script (installing more packages, etc. if you want). However, your bash script test file will be timed out **after 30 seconds**. Therefore, make sure, all of your testing can happen within 30 seconds.

## Step 5 - Test file

In the same `Evaluation` tab, you'll see another section called "Custom test file". You can use this test file to add custom code for testing user work.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000002%402x.mhhqir.png)

When you click on it, a new window will open. This is a test file area.

You can write anything here. Whatever script you write here, can be executed from the `Test command to run section` inside the evaluation tab we were in earlier.

The point of having a file like this to provide you with a place where you can write your evaluation script.

**Note: For Python labs, I'm assuming you will be using the pre-installed pytest utility to test the user code. Hence, we use the pytest testing format here:**

```py theme={null}
import os
import sys
import importlib
# Make user code files available for dynamic import
sys.path.append(os.environ.get('USER_CODE_DIR'))

# Docs: https://docs.pytest.org/en/6.2.x/getting-started.html#create-your-first-test

def test_variable1():
	userscript = importlib.import_module('script')
	assert userscript.variable1 == 5

def test_variable2():
	userscript = importlib.import_module('script')
	assert userscript.variable2 == 300

```

Let us understand what is happening here exactly:

* We import some required python packages.

* Then we add `USER_CODE_DIR` to the `PATH` env. `USER_CODE_DIR` string is effectively `/home/damner/code` which in turn is the directory where your students store their coding files (and is also visible in the playground file explorer by default)

* We start writing tests on how Python pytest library recommends. Check out [pytest documentation](https://docs.pytest.org/en/6.2.x/getting-started.html#create-your-first-test) for more information.

* We dynamically import the `script.py` using `importlib.import_module('script')`. This is to prevent the test file from crashing other tests in case the script is not there at all.

* Then we start asserting based on pytest utilities.

* The number of `def test_(...)` functions inside your test file suite should match the number of challenges added in the creator area.

* **Note:** If your number of `test` blocks are less than challenges added back in the UI, the "extra" UI challenges would automatically stay as "false". If you add more challenges in test file, the results would be ignored.

This completes your evaluation script for the lab. Your lab is now almost ready for users.

## Step 6 - Add challenges

Finally, in the UI below, add friendly name of challenges that must be visible to the user. Note that the order of challenges is important here and must match the boolean array you write using the bash script + test file above.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000003%402x.bedrfe.png)


# React.js lab with Vitest
Source: https://docs.fermion.app/creating-coding-labs/technologies/react

Build dynamic React.js labs integrated with Vitest for live component testing

Coding labs is a powerful feature of Fermion. Using coding labs in your platform, you can increase user retention, provide hands-on experience to them, and make them learn-by-doing.

Let's take a look at how you can setup a React.js interactive coding lab in this guide.

## Step 1 - Creating the Lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab Instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults section include how your lab environment boots. It is one of the most important parts because a wrong default environment might confuse your students. Therefore it is important to set it up properly.

When a playground boots, it can setup a filesystem for user by default. You can specify what the starting files could be, by specifying a git repository and a branch name:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-2024-11-17-3%E2%80%AF-31-53%402x.kzdbiv.png)

<Info>
  For React playground, we recommend you to fork the following repository and use it as a starter template: [React vite playground starter](https://github.com/codedamn-projects/react-vite-playground)

  Avoid using webpack to setup React.js playgrounds as vite is much faster.
</Info>

You will find a `.cdmrc` file in the repository given to you above. It is highly recommend, at this point, that you go through the [.cdmrc guide and how to use .cdmrc in playgrounds](/creating-coding-labs/cdmrc-file) to understand what `.cdmrc` file exactly is. Once you understand how to work with `.cdmrc` come back to this area.

## Step 4 - Evaluation script

Evaluation script is actually what runs when the user on the playground clicks on "Run Tests" button.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/lab-run-tests.exllxt.png)
![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000001%402x.ywpfjc.png)

Remember that we're using React Vite playground setup. This means we can assume that we already have vite installed.

However, we still need to setup a lot of things: `jsdom`, `vitest`, and `react-testing-library`. Therefore, we can write our evaluation bash script to install all of this and run our tests. Here's how the React vitest script looks like:

```bash theme={null}
#!/bin/bash
set -e 1

# Assumes you are running a react vite playground

# Install vitest and testing util
cd /home/damner/code
yarn add vitest@0.32.2 jsdom@22.1.0 @testing-library/jest-dom@5.16.5 @testing-library/react@14.0.0 --dev
mkdir -p /home/damner/code/.labtests

# Move test file
mv $TEST_FILE_NAME /home/damner/code/.labtests/reactcheck.test.jsx

# setup file
cat > /home/damner/code/.labtests/setup.js << EOF
import '@testing-library/jest-dom'
EOF

# vitest config file
cat > /home/damner/code/.labtests/config.js << EOF
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

// https://vitejs.dev/config/
export default defineConfig({
	plugins: [react()],
    test: {
        globals: true,
        environment: 'jsdom',
        setupFiles: '/home/damner/code/.labtests/setup.js',
    }
})
EOF

# process.js file
cat > /home/damner/code/.labtests/process.js << EOF
import fs from 'node:fs'
const payload = JSON.parse(fs.readFileSync('./payload.json', 'utf8'))
const answers = payload.testResults[0].assertionResults.map(test => test.status === 'passed')

fs.writeFileSync(process.env.UNIT_TEST_OUTPUT_FILE, JSON.stringify(answers))
EOF

# package.json
cat > /home/damner/code/.labtests/package.json << EOF
{
    "type": "module"
}
EOF

# run test
(yarn vitest run --config=/home/damner/code/.labtests/config.js --threads=false --reporter=json --outputFile=/home/damner/code/.labtests/payload.json || true)  | tee /home/damner/code/.labtests/evaluationscript.log

# Write results to UNIT_TEST_OUTPUT_FILE to communicate to frontend
cd /home/damner/code/.labtests
node process.js
```

You might need to have a little understanding of bash scripting. Let us understand how the evaluation bash script is working:

* With `set -e 1` we effectively say that the script should stop on any errors
* We then navigate to user default directory `/home/damner/code` and then install the required NPM packages. Note that this assumes we already have `vite` installed. If you're using a different react setup (like `create-react-app`), you might have to install `vite` as well.
* You can install additional packages here if you want. They would only be installed the first time user runs the test. On subsequent runs, it can reuse the installed packages (since they are not removed at the end of testing)
* Then we create a `.labtests` folder inside of the `/home/damner/code` user code directory. Note that `.labtests` is a special folder that can be used to place your test code. This folder will not be visible in the file explorer user sees, and the files placed in this folder are not "backed up to cloud" for user.
* We move the test file you wrote earlier (in last step) to `/home/damner/code/.labtests/reactcheck.test.jsx`. Note that it is important to give it an extension of `.test.jsx` for vitest to pick it as a JSX test file.
* We then create another setup file `/home/damner/code/.labtests/setup.js` with just `jsdom` as the import. This is because vitest can then use JSDOM to parse the DOM without browser. More information about this [setup file can be found in vitest docs here](https://vitest.dev/config/#setupfiles).
* We then also create a custom vite config file as `config.js`. This is because we don't want to override your (or users') custom `vite.config.js` file if present. This file only loads `jsdom` and marks the `globals: true` hence importing `describe`, `test`, etc. automatically available without importing. More information about the configuration can be found here in [vitest docs](https://vitest.dev/config/#globals).
* We then create a `process.js` file that can be used to process our results into a single file of boolean values. This is important because on the playground page, the way challenges work, is that they get green or red based on a JSON boolean array written inside the file in environment variable: `$UNIT_TEST_OUTPUT_FILE`
* For example, once the test run succeeds, and if you write `[true,false,true,true]` inside `$UNIT_TEST_OUTPUT_FILE`, it would reflect as PASS, FAIL, PASS, PASS for 4 challenges available inside playground UI (as shown below)

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/playground-tests-2.tmstkq.png)

* Then we run the actual test using `yarn vitest run` command, specifying the output as JSON (read by `process.js`) and in a single thread (as we want ordered results).

* Finally we run the `process.js` file that writes the correct JSON boolean array on `$UNIT_TEST_OUTPUT_FILE` which is then read by the playground UI and marks the lab challenges as pass or fail.

**Note:** You can setup a full testing environment in this block of evaluation script (installing more packages, etc. if you want). However, your bash script test file will be timed out **after 30 seconds**. Therefore, make sure, all of your testing can happen within 30 seconds.

Next step is to setup test file for this lab.

## Step 5 - Test file

In the same `Evaluation` tab, you'll see another section called "Custom test file". You can use this test file to add custom code for testing user work.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000002%402x.mhhqir.png)

When you click on it, a new window will open. This is a test file area.

You can write anything here. Whatever script you write here, can be executed from the `Test command to run section` inside the evaluation tab we were in earlier.

The point of having a file like this to provide you with a place where you can write your evaluation script.

**For React.js labs, you can use the React (Vitest) evaluation script:**

```jsx theme={null}
import '@testing-library/jest-dom'
import * as React from 'react'
import { render, fireEvent, screen, waitFor } from '@testing-library/react'

// Import the user component if you want
import App from '/home/damner/code/src/App'

describe('Test runner suite', () => {
	// Sample test - each "test" block will be linked to individual challenge
	test('App should mount correctly', async () => {
		const { container } = render(<App />)
		expect(container.querySelector('main')).toBeInTheDocument()
	})
})
```

Let us understand what is happening here exactly:

* Remember that we can code anything in this file and then execute it later. In this example, we're writing a React.js Vitest test script from scratch. Check out [vitest docs](https://vitest.dev) if you're new to vitest.
* Remember that we will install vitest and other required utilities in the evaluation script section below. Therefore, you can try to import and use anything and everything here you want.
* The rest of the code is just importing the default user code, and testing it through standard unit testing procedures.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/playground-tests.geugve.png)

* The number of `test(...)` blocks inside your `describe` suite **must match the number of challenges** added in the creator area.

* **Note:** If your number of `test` blocks are less than challenges added back in the UI, the "extra" UI challenges would automatically stay as "false". If you add more challenges in test file, the results would be ignored. Therefore, it is **important** that the `results.length` is same as the number of challenges you added in the challenges UI.

* We then also add jQuery and chai for assisting with testing. Although it is not required as long as you can populate the `results` array properly.

This completes your evaluation script for the lab. Your lab is now almost ready for users.

## Step 6 - Add challenges

Finally, in the UI below, add friendly name of challenges that must be visible to the user. Note that the order of challenges is important here and must match the boolean array you write using the bash script + test file above.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/screenshot-000003%402x.bedrfe.png)


# Rust Lab
Source: https://docs.fermion.app/creating-coding-labs/technologies/rust

Create secure Rust programming environments where learners can compile and execute Rust code safely.

**Coding labs** are a powerful feature of Fermion. By integrating coding labs into your platform, you can enhance user retention, provide hands-on experience, and encourage a learn-by-doing approach.

This guide walks you through setting up a Rust interactive coding lab.

<iframe />

## Step 1 - Creating the Lab

* Add a new item lab in your course curriculum page

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/55%402x.vscibv.png)

* A new lab item gets added. Edit the lab using the controls:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/07%402x.nnfiay.png)

* A lab item in a course can be attached to an existing lab you created in the past. If not, you can create a new lab with this Edit interface:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/05%402x.pmogtp.png)

* You should now be able to write a quick lab name and press on "Create Lab" button. Once you do, press on `Attach to course item` button. Once that is done, click the three dots again and click on "Edit" to edit the lab.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/31%402x.phplpv.png)

## Step 2 - Lab Instructions

Once you click on `Edit` button a new page will open. On this page you need to setup instructions for lab. These instructions would be visible to the user when they're attempting the lab. Therefore, include all the helper material, lab setup instructions here.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/17-11-2024/00%402x.daeltt.png)

## Step 3 - Lab Defaults

Lab defaults define the initial environment setup for the lab. It is crucial to configure this correctly to avoid confusing students.

For Rust labs, the playground must initialize a valid Rust project. You can do this by specifying a Git repository and branch with a basic `Cargo` project structure:

<Info>
  We recommend forking this repository: [Rust playground
  starter](https://github.com/codedamn-classrooms/rust-coding-lab-starter).
</Info>

This repository contains a minimal Rust project with a `Cargo.toml` file and a `src/main.rs` file. Once forked, update the repository link in your lab settings.

The repository also includes a `.cdmrc` file, a critical configuration file for Fermion labs. Familiarize yourself with the [.cdmrc guide](/creating-coding-labs/cdmrc-file) to understand how it works before proceeding.

## Step 4 - Evaluation Script

The evaluation script is executed when the user clicks the **"Run Tests"** button in the playground. It runs the test cases written for the lab.

Here's a sample bash script for a Rust lab:

```bash theme={null}
#!/bin/bash
set -e 1

# Create a `.labtests` directory to store test files
mkdir -p /home/damner/code/.labtests

# Move the provided test file into the `.labtests` folder
mv $TEST_FILE_NAME /home/damner/code/.labtests/test.rs

cd /home/damner/code/.labtests;
rustc test.rs && ./test
```

* We simply download the test file (we create in next step), and run it with `rustc`

## Step 5 - Test File

In the **"Custom Test File"** section of the lab, you can define test cases to validate the user's code.

Here's a sample Rust test file:

```rust theme={null}
// Include the user's default `lib.rs` file as usercode module
#[path = "/home/damner/code/src/lib.rs"]
mod usercode;

use usercode::*;
use std::env;
use std::fs::File;
use std::io::Write;

fn main() {
    let mut results = Vec::new();

    // Test 1
    results.push(run_test(|| {
        let a = 1;
        let b = 2;
        let res = add(a, b);
        res == 3
    }));

    // Test 2
    results.push(run_test(|| {
        let a = 2;
        let b = 3;
        let res = add(a, b);
        res == 5
    }));

    // Get output file path from environment variable
    let output_file = env::var("UNIT_TEST_OUTPUT_FILE")
        .expect("Environment variable UNIT_TEST_OUTPUT_FILE must be set");

    // Write results to the specified file in JSON format
    if let Err(e) = write_results_to_file(&results, &output_file) {
        eprintln!("Failed to write results to {}: {}", output_file, e);
    }
}

fn run_test<F>(test_fn: F) -> bool
where
    F: FnOnce() -> bool,
{
    test_fn()
}


fn write_results_to_file(results: &[bool], file_path: &str) -> std::io::Result<()> {
    // Manually format the boolean array as a JSON string
    let json_results = format!(
        "[{}]",
        results
            .iter()
            .map(|&b| b.to_string()) // Convert bool to "true"/"false"
            .collect::<Vec<_>>()
            .join(", ")
    );

    // Write the JSON string to the file
    let mut file = File::create(file_path)?;
    file.write_all(json_results.as_bytes())?;
    Ok(())
}
```

### Key Points

* The length of boolean array `results` must match the challenges defined in the UI.
* Tests must be executed sequentially and in order. This is because the boolean array you write to the output file must match the order in which you add challenges in the UI. This is why we don't use `cargo test` and instead run a rust script manually.

## Step 6 - Add Challenges

In the Fermion UI, define the challenges corresponding to the tests. Ensure the order of challenges matches the order of test cases in your test file.

For example:

* Challenge 1: Verify the `add` function works correctly with input 1,2.
* Challenge 2: Verify the `add` function works correctly with input 2,3.

This mapping ensures that the playground accurately reflects the user's progress.

***

Your interactive Rust lab is now ready! Students will be able to practice and learn Rust through real-world challenges, with tests running in a predictable, sequential order.


# Introduction
Source: https://docs.fermion.app/creating-coding-labs/what-are-coding-labs

Learn about what interactive coding labs are on Fermion and how you can use them

*Another mind-boggling reason why Fermion stands out among other traditional LMS platforms is its ability to integrate interactive coding labs at the click of a button!*

Coding labs on Fermion are highly powered linux environment which boot in under 3 seconds, and give learners almost a VSCode-like experience on web. These labs are highly interactive and evaluative in nature, let's look at a coding lab below:

![wQVmQFIXo\_sH1XQ9yyxN\_](https://creator-assets.codedamn.com/fermion-instructor/02-08-2024/instructor_66467ae8ada1f52e23942268/wQVmQFIXo_sH1XQ9yyxN_)

This lab includes a powerful editor, terminal and browser preview.

Alongside, it also includes an `Instructions` and `Challenges` section so that students know exactly what they have to do when they land on your lab.

![xcWDPvkImYvEmV0WWfbp3](https://creator-assets.codedamn.com/fermion-instructor/02-08-2024/instructor_66467ae8ada1f52e23942268/xcWDPvkImYvEmV0WWfbp3)

We make sure that when you are teaching a technical concept, students aren't simply just learning, but they're learning by doing. These labs force students to solve hands-on, what they've just learnt by you.

We believe in the philosophy of learning by doing, and we've brought the same concept to Fermion by letting technical you integrate hands-on interactive and evaluative coding labs in seconds.

With over 5000+ coding labs and quiz questions available, you can easily add interactive and evaluative elements to your courses.

This helps your courses stand out in the market by offering a practical learning experience that is crucial for aspiring developers.

Not just this, you can go beyond and even add hands-on coding projects as well as interview kits inside your courses.


# AI Copilot
Source: https://docs.fermion.app/creating-io-coding-labs/ai-agent

Create intelligent coding labs for DSA / IO problems using the Fermion Copilot.

## What is agentic AI in labs?

Fermion Copilot is powered by an **agentic AI** system designed to understand natural language and take autonomous actions to build structured [coding labs](/creating-io-coding-labs/introduction). Instead of manually configuring problem statements, test cases, and setups, you can simply describe the lab you want in plain English, and the Copilot will generate it for you.\
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_sqcPfdSPd0.dvmkwy.png)

This is an intelligent model that grasps the intent, context, and structure of your request, moving far beyond simply populating templates. You can give it instructions like **"Create a DSA problem to find the longest common prefix in a list of strings"** or **"Build an IO lab for calculating factorial using recursion"**. The Copilot will then automatically generate a complete lab, including the problem description, coding environment, and relevant test cases, all specifically tailored to what you asked for.

<Info>
  Before you can access **Coding Labs**, make sure that Coding Labs are **enabled for your school**.\
  Learn more on how to [manage features](/manage-settings/manage-features)
</Info>

## Create IO labs using Fermion copilot

You can utilize the following steps to create an IO lab with the help of Fermion Copilot:

<Steps>
  <Step title="Open IO Labs">
    Head over to the **Coding Labs** section, select **Labs**, and then choose **IO Labs** from the available options.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_JfD4U2VcEc.tzbzvl.png)
  </Step>

  <Step title="Create a new lab">
    Click **Create new lab** and give your lab a meaningful **name** that reflects the problem you want to design.
  </Step>

  <Step title="Prompt the Fermion copilot">
    On the right pane, you’ll find the **Fermion Copilot** interface.\
    Here, you can provide simple **natural language prompts**, describing the problem you want to create.
    The Copilot will then automatically generate a complete lab for that problem: including the **problem statement**, **input/output format**, and **test cases**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_BpQC0TFrfe.wnwcog.png)
    Now, let us prompt the agent to create a lab around the famous **Two Sum** problem\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_1m83J7efff.xpdsgd.png)
  </Step>

  <Step title="AI clarifications and confirmations">
    Before making any permanent changes, the Copilot will **ask for clarifications** if something in your prompt is ambiguous. You can reply to the agent in the same window and the agent will preserve all the context and create a lab for you.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_Usfvi4hxLP.rbvmkp.png)
    It will also **seek your confirmation** before applying modifications, ensuring you stay in control of every AI-generated edit.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_mPgEeVCMS0.fthlig.png)
  </Step>

  <Step title="Generate lab and test cases">
    Once you provide the agent with the **confirmation to proceed**, the Fermion Copilot will automatically **generate the complete lab description** for your problem.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_lUDwegyQrJ.zwqrjg.png)

    The AI agent will also **generate suitable test cases** for the same lab, ensuring comprehensive coverage of typical and edge scenarios.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_WmDhlOCucr.sdralp.png)

    You can continue the conversation with the agent if you wish to **generate more test cases**, refine the difficulty level, or improve the problem’s structure, all without leaving the lab builder.
  </Step>

  <Step title="Configure lab settings (human-in-the-loop)">
    Although the Copilot automates most of the lab creation, you’ll still need to manually configure certain parameters:

    <AccordionGroup>
      <Accordion title="Allowed languages">
        Select which programming languages students can use to solve the problem:

        * C
        * C++
        * Java
        * Node.js (JavaScript)
        * Python 3
        * Rust 1.87
        * Go 1.19
        * .NET 8
      </Accordion>

      <Accordion title="Matcher type">
        Define how the expected output and user’s output should be compared:

        * **Exact match**: Character-by-character comparison
        * **Ignore whitespace at start and end**
        * **Ignore case and whitespace at start and end**
        * **Ignore whitespace in every line at start and end**
        * **Ignore case and whitespace in every line at start and end**
      </Accordion>

      <Accordion title="Advanced settings">
        Customize execution limits if needed. The default values are optimal for most labs:

        * **Maximum CPU time:** 2000 ms
        * **Maximum wall time:** 5000 ms
        * **Maximum memory:** 512000 KB
      </Accordion>
    </AccordionGroup>
  </Step>

  <Step title="Save and try out the lab">
    Once everything looks good, click **Save Changes** and **try out your lab** to ensure everything functions as expected.
  </Step>
</Steps>

AI-powered lab creation streamlines your workflow by reducing repetitive setup tasks while keeping you in control of final configurations. Fermion Copilot acts as your intelligent coding lab builder: fast, accurate, and always ready to help you build high-quality coding challenges with just a prompt.

***

## Next steps

<Columns>
  <Card title="SQL Labs" href="/creating-io-coding-labs/sql-lab">
    Learn how to create and manage SQL-based coding labs where students can run real database queries, test schema design, and validate SQL output directly in the browser.
  </Card>

  <Card title="Embed IO Labs" href="/creating-io-coding-labs/embed-lab">
    Discover how to embed your IO Labs into external pages. Enable students to solve coding problems interactively without leaving the learning experience.
  </Card>
</Columns>


# Introduction
Source: https://docs.fermion.app/creating-io-coding-labs/api-usage

Learn about using APIs to execute DSA coding labs

The DSA Coding Lab Execution API allows you to programmatically execute code submissions and retrieve results for Data Structures and Algorithms (DSA) problems. This API supports batch operations for efficiency and handles multiple programming languages.

## Overview

The API provides four main endpoints which you can utilize to execute DSA coding labs over Fermion API.

<Columns>
  <Card title="Request DSA code execution" href="/api-reference/dsa/request-dsa-code-execution-[single]">
    Submit a single code execution request.
  </Card>

  <Card title="Get DSA code execution result" href="/api-reference/dsa/get-dsa-code-execution-result-[single]">
    Retrieve the result of a single code execution.
  </Card>

  <Card title="Request DSA code execution [batch]" href="/api-reference/dsa/request-dsa-code-execution-[batch]">
    Submit multiple code execution requests in one batch.
  </Card>

  <Card title="Get DSA code execution result [batch]" href="/api-reference/dsa/get-dsa-code-execution-result-[batch]">
    Retrieve results of multiple code executions submitted in a batch.
  </Card>
</Columns>

## Prerequisites

Before you begin using the DSA Execution API, make sure you’ve set up the following essential components.

<AccordionGroup>
  <Accordion title="Fermion API Key" icon="key">
    You must have a valid Fermion API key to run these coding labs. Create a Fermion account and go to **Settings → API access** in your instructor dashboard to get the key.\
    Learn how to get your [API key here](/api-guide/introduction#how-to-get-your-api-key).
  </Accordion>
</AccordionGroup>

#### Base64URL Encoded source code

Base64URL encoding is **critical** for proper API usage.\
The DSA execution API requires Base64URL encoding (not standard Base64) for several fields including **source code**, **expected output**, **stdin input**, and **file attachments** for [SQL labs](/creating-io-coding-labs/sql-over-api).
Base64URL encoding is a URL-safe variant of the standard Base64 format. It’s designed to ensure that encoded data can be safely transmitted in URLs, JSON, and APIs without introducing reserved or invalid characters.

Base64URL encoding is a URL-safe variant of Base64 that:

* Replaces `+` with `-` (dash)
* Replaces `/` with `_` (underscore)
* Removes padding `=` characters
* Ensures the encoded string is safe for use in URLs and JSON

<Warning>
  Using standard Base64 encoding instead of Base64URL will cause API errors or
  unexpected behavior. Always use Base64URL encoding for the API. Learn more about [Base64URL encoding](https://b64encode.com/blog/base64url-guide/)
</Warning>

## Supported languages

Fermion currently supports the following runtimes for code execution:

<Columns>
  <Card title="C / C++" icon="C" />

  <Card title="Java" icon="java" />

  <Card title="Python" icon="python" />

  <Card title="Node.js (JavaScript)" icon="node-js" />

  <Card title="SQLite / MySQL 8" icon="database" />

  <Card title="Go (1.19)" icon="golang" />

  <Card title="Rust (1.87)" icon="rust" />

  <Card title=".NET 8" icon="hashtag" />
</Columns>

Each language runs in a secure, isolated container with seperate resources.

## How to execute IO/DSA labs over API?

You can utilize the following steps to execute DSA over API. If you wish to test how a request is structured for any given language, head over to the [compile API](/creating-io-coding-labs/api-usage#how-does-compile-api-work%3F) section of this documentation to learn more.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/Untitled-2025-02-04-2040.fanymm.png)

<Steps>
  <Step title="Submit code for execution">
    Use the **Request DSA code execution \[batch]** endpoint to submit one or more code executions.

    For detailed API specification, request/response schemas, and interactive examples, see the official API documentation: [Request DSA code execution \[batch\]](https://docs.fermion.app/api-reference/dsa/request-dsa-code-execution-\[batch])

    Here is an empty sample request body for executing C code over API. Head over to the [runConfig documentation](/creating-io-coding-labs/api-usage#run-configuration-runconfig) to know more about each field

    ```json theme={null}
    {
      "data": [
        {
          "data": {
            "entries": [
              {
                "language": "C",
                "runConfig": {
                  "customMatcherToUseForExpectedOutput": "ExactMatch",
                  "expectedOutputAsBase64UrlEncoded": "",
                  "stdinStringAsBase64UrlEncoded": "",
                  "callbackUrlOnExecutionCompletion": "",
                  "shouldEnablePerProcessAndThreadCpuTimeLimit": false,
                  "shouldEnablePerProcessAndThreadMemoryLimit": false,
                  "shouldAllowInternetAccess": false,
                  "compilerFlagString": "",
                  "maxFileSizeInKilobytesFilesCreatedOrModified": 51200,
                  "stackSizeLimitInKilobytes": 65536,
                  "cpuTimeLimitInMilliseconds": 2000,
                  "wallTimeLimitInMilliseconds": 5000,
                  "memoryLimitInKilobyte": 512000,
                  "maxProcessesAndOrThreads": 60
                },
                "sourceCodeAsBase64UrlEncoded": "",
                "additionalFilesAsZip": {
                  "type": "base64url-encoding",
                  "base64UrlEncodedZip": ""
                }
              }
            ]
          }
        }
      ]
    }
    ```

    The API returns an array of task IDs in the same order of challenges that you submitted, that you can use to retrieve results later.

    ```json theme={null}
    {
        "output": 
    	{
          "status": "ok",
          "data": 
    	  {
            "taskIds": [ "<string>"]
          }
        }
    }
    ```
  </Step>

  <Step title="Retrieve execution results">
    Use the **[Get DSA code execution result \[batch\]](/api-reference/dsa/get-dsa-code-execution-result-\[batch])** endpoint to retrieve results of submitted executions. You will have to pass the Fermion API key so that we can authenticate your request

    Here's a sample cURL request to get the execution results of the task IDs returned from the previous endpoint

    ```bash theme={null}
    curl --request POST \
      --url https://backend.codedamn.com/api/public/get-dsa-code-execution-result-batch \
      --header 'Content-Type: application/json' \
      --header 'FERMION-API-KEY: <api-key>' \
      --data '{
      "data": [
        {
          "data": {
            "taskUniqueIds": [
              "<string>"
            ]
          }
        }
      ]
    }
    ```

    For detailed API specification, request/response schemas, and interactive examples, see the official API documentation: [Get DSA code execution result \[batch\]](https://docs.fermion.app/api-reference/dsa/get-dsa-code-execution-result-\[batch])
  </Step>
</Steps>

***

## Request DSA code execution

The request to the [Request DSA code execution](/api-reference/dsa/request-dsa-code-execution-\[single]) endpoint contains a **language field**,  **runConfig** object,  source code as base64URL encoded, and additional files if we are executing [SQL over API](/creating-io-coding-labs/sql-over-api)
Here is a description of these fields to be provided while sending a request.

### Run Configuration (runConfig)

The runConfig object defines execution parameters and resource limits for each code run. These settings control performance, safety, and sandbox behavior during code execution.

| Field Name                                     | Description                                                                                           |
| ---------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `customMatcherToUseForExpectedOutput`          | Defines how program output is compared with the expected output. Common options include `ExactMatch`. |
| `expectedOutputAsBase64UrlEncoded`             | Base64URL-encoded expected output string.                                                             |
| `stdinStringAsBase64UrlEncoded`                | Base64URL-encoded standard input string for the program.                                              |
| `callbackUrlOnExecutionCompletion`             | Optional webhook URL that receives a callback once execution completes.                               |
| `shouldEnablePerProcessAndThreadCpuTimeLimit`  | Enables CPU time limits per process/thread if set to `true`.                                          |
| `shouldEnablePerProcessAndThreadMemoryLimit`   | Enables memory limits per process/thread if set to `true`.                                            |
| `shouldAllowInternetAccess`                    | Allows or restricts outbound internet access for the running code.                                    |
| `compilerFlagString`                           | Optional compiler flags or arguments to use during code compilation.                                  |
| `maxFileSizeInKilobytesFilesCreatedOrModified` | Maximum allowed size (in KB) for any file created or modified during execution. *(Default: 51200)*    |
| `stackSizeLimitInKilobytes`                    | Maximum stack size (in KB) allocated for the program. *(Default: 65536)*                              |
| `cpuTimeLimitInMilliseconds`                   | Maximum CPU time (in ms) the program can use. *(Default: 2000)*                                       |
| `wallTimeLimitInMilliseconds`                  | Maximum total wall time (in ms) allowed for execution. *(Default: 5000)*                              |
| `memoryLimitInKilobyte`                        | Maximum total memory (in KB) that the program may consume. *(Default: 512000)*                        |
| `maxProcessesAndOrThreads`                     | Maximum number of processes and/or threads the program can spawn. *(Default: 60)*                     |

### Required Fields

The following fields **must** be Base64URL encoded and sent as part of the request body:

| Field Name                         | Description                                                                       |
| ---------------------------------- | --------------------------------------------------------------------------------- |
| `sourceCodeAsBase64UrlEncoded`     | Your source code                                                                  |
| `expectedOutputAsBase64UrlEncoded` | Expected program output, API will judge the program output in accordance to this. |
| `stdinStringAsBase64UrlEncoded`    | Input data for the program                                                        |
| `base64UrlEncodedZip`              | ZIP file contents for SQLite                                                      |

The response from this API provides us with `taskId` which we can use to get the result from the [Get DSA code execution result](/api-reference/dsa/get-dsa-code-execution-result-\[batch]) endpoint

## Get DSA code execution result

After we have received the `taskId` from the previous endpoint, we can send this task ID to the [Get DSA code execution result](/api-reference/dsa/get-dsa-code-execution-result-\[single]) and get the execution result. The API returns a  `taskUniqueId`, `language` and the `runConfig` provided at the time of request. Apart from this, the response has `codingTaskStatus` which tells us if the code has been executed or not, a `runResult` object which tells us about the execution of the code.

### codingTaskStatus  Values

Each submitted coding task in Fermion's DSA execution API has a `codingTaskStatus` that indicates its current stage of processing. The `codingTaskStatus` can have the following values:

| Status           | Description                      |
| ---------------- | -------------------------------- |
| **`Pending`**    | Task is queued for execution     |
| **`Processing`** | Task is currently being executed |
| **`Finished`**   | Task execution completed         |

### runResult object

The runResult object contains information regarding the execution of the code and the program data after the code execution. The following fields are part of the runResult object.

| Field                                            | Description                                                              |
| ------------------------------------------------ | ------------------------------------------------------------------------ |
| `compilerOutputAfterCompilationBase64UrlEncoded` | Base64-encoded compiler output.                                          |
| `finishedAt`                                     | Timestamp representing when the execution finished.                      |
| `runStatus`                                      | Status of the code run e.g., `successful`, `compilation-error`,          |
| `programRunData.cpuTimeUsedInMilliseconds`       | CPU time consumed by the program (in milliseconds).                      |
| `programRunData.wallTimeUsedInMilliseconds`      | Total elapsed (wall) time for execution (in milliseconds).               |
| `programRunData.memoryUsedInKilobyte`            | Memory used by the program (in kilobytes).                               |
| `programRunData.exitSignal`                      | Signal number if the program was terminated by the system.               |
| `programRunData.exitCode`                        | Exit code returned by the program after execution.                       |
| `programRunData.stdoutBase64UrlEncoded`          | Base64-encoded standard output (stdout) from the executed program.       |
| `programRunData.stderrBase64UrlEncoded`          | Base64-encoded standard error (stderr) output from the executed program. |

### runStatus Values

The `runStatus` field inside runResult provides detailed feedback about the outcome of code execution. The `runStatus` field can have the following values:

| Status                       | Description                          |
| ---------------------------- | ------------------------------------ |
| **`successful`**             | Code executed successfully           |
| **`compilation-error`**      | Code failed to compile               |
| **`time-limit-exceeded`**    | Execution exceeded time limit        |
| **`wrong-answer`**           | Output doesn't match expected result |
| **`non-zero-exit-code`**     | Program exited with non-zero code    |
| **`died-sigsev`**            | Segmentation fault                   |
| **`died-sigxfsz`**           | File size limit exceeded             |
| **`died-sigfpe`**            | Floating point exception             |
| **`died-sigabrt`**           | Program aborted                      |
| **`internal-isolate-error`** | Internal system error                |
| **`unknown`**                | Unknown error occurred               |

This was an example flow for single DSA code execution request. The same flow can be followed for batch execution of codes using the batch endpoints.

## Using webhook URLs for instant results (recommended)

Instead of polling for results, it's recommended to use the`callbackUrlOnExecutionCompletion` parameter in your `runConfig`. This
webhook URL will receive a POST request with the execution results immediately when processing completes, eliminating the need for repeated
polling and providing faster response times.

<Tip>
  When using webhook URLs, include the `callbackUrlOnExecutionCompletion` in
  your execution request
</Tip>

```json theme={null}
{
	"language": "Python",
	"sourceCodeAsBase64UrlEncoded": "cHJpbnQoImhlbGxvIHdvcmxkIik=",
	"runConfig": {
		"callbackUrlOnExecutionCompletion": "https://your-domain.com/webhook/execution-complete",
		"customMatcherToUseForExpectedOutput": "ExactMatch",
		"expectedOutputAsBase64UrlEncoded": "aGVsbG8gd29ybGQK",
		"cpuTimeLimitInMilliseconds": 2000,
		"wallTimeLimitInMilliseconds": 5000,
		"memoryLimitInKilobyte": 131072
	}
}
```

Your webhook endpoint will receive the complete execution result as a POST request body, containing the same data structure as the batch result API response.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/Untitled-2025-02-04-2041.ylwqco.png)

***

The **Compile API** allows you to execute arbitrary code in a secure, sandboxed environment directly through Fermion’s backend. This is ideal for online coding exercises, testing snippets, or building coding playgrounds on your platform.

You can send a POST request with your source code and configuration details, and the API returns the program’s output, error messages, and execution metadata, right inside your instructor dashboard.

<Check>
  Before you start, make sure **Coding labs** are enabled under **Manage Features** in your instructor dashboard. Learn how to enable features at Fermion [here](/manage-settings/manage-features)
</Check>

***

## How does compile API work?

We discussed how we can execute DSA / IO codes over API in the previous sections. You can test how a request body would look like right inside your Fermion instructor dashboard with the help of the following steps.

You can access compile API tab directly inside your instructor dashboard by heading over to **Coding labs** → **Compile API**.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_74extBr1hQ.lrrdgl.png)

Select the language you want to test the compile API for. After accessing this section, you will be presented with the following two panes:

<Columns>
  <Card title="Write and Run Code">
    On the left side, you can write and edit your source code in the built-in editor using any of the supported languages.
    Simply choose the language from the dropdown and click **Run code** to execute it securely in Fermion’s sandboxed environment.
  </Card>

  <Card title="API Preview">
    On the right side, you can view the automatically generated **cURL request**: showing exactly how to call the Fermion Compile API programmatically. As you can see the source code is Base64URL encoded inside the request body.
  </Card>
</Columns>

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_DwdJJL8IeA.kprbaj.png)

After clicking **Run code**, you will see the execution results, including status, timing, memory usage, and program output. Example:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_03ChiHatr6.mlgwpt.png)

## Industry Pricing Comparison

Fermion offers the best infrastructure and extremely competitive prices compared to industry standards. For example, consider Judge0's pricing on RapidAPI vs Fermion's base plan pricing.

| Platform            | Cost per Submission       | Rate limits                |
| ------------------- | ------------------------- | -------------------------- |
| **Judge0**          | \$1 per 1,000 submissions | Unknown                    |
| **Fermion DSA API** | \$1 per 5,000 submissions | 10,000 requests per second |

<Info>
  Planning to execute more than 1 million runs per month? Contact our
  team at [support@codedamn.com](mailto:support@codedamn.com) for special enterprise pricing and higher rate limits.
</Info>

**Why Choose Fermion over Judge0?**

* **Better Performance**: Optimized specifically for DSA problems
* **Batch Operations**: Execute multiple problems in a single API call
* **Enterprise Support**: Dedicated support for high-volume users
* **Competitive Pricing**: Better rates for volume usage

<Check>
  Fermion's DSA execution API is a production-ready, enterprise-grade
  replacement for Judge0 with better performance, reliability, and pricing.
</Check>


# Creating an IO Lab
Source: https://docs.fermion.app/creating-io-coding-labs/creating-io-lab-successfully

Learn about best practices for creating a functional IO lab on Fermion

Creating an I/O lab on Fermion requires you to follow several best practices to ensure your lab functions correctly and provides a good learning experience.

## Understanding I/O Lab Philosophy

Fermion labs are built on the philosophy of having an input and an expected output. In many cases, the expected output can have multiple spaces, line breaks, and other formatting elements. Therefore, it is crucial that you select the right matcher for your specific use case.

## Available Matchers

There are multiple matchers available in Fermion I/O lab setup that allow you to configure how the expected output of the program is matched with the real output that the user generates:

* **Exact Match**: Use this when you need the output to match exactly, including all spaces, tabs, and line breaks
* **Other matchers**: Available for different matching requirements

For example, if you want an exact match, you must use the exact output matcher.

## Test Case Configuration

When creating an I/O lab, you can specify some test cases as **sample test cases**. If you mark a test case as a sample test case, it becomes visible to the end user, allowing them to understand the expected input-output format before attempting the lab.

## Troubleshooting: Code Output vs Test Case Failure

### Common Issue: Right Output, Failing Test Case

If your code produces the correct output but your test case is still failing, please double-check the following:

1. **Spacing Issues**: Ensure there are no extra or missing spaces in your expected output
2. **New Line Issues**: Verify that line breaks match exactly between expected and actual output
3. **Character Issues**: Check for any hidden characters, tabs, or different character encodings

### Matcher Type Considerations

If you're using an **exact match** matcher, your lab will fail even if there's a single new line, tab, or different character difference. Make sure your expected output matches the actual output character-for-character.


# Embed an IO Lab
Source: https://docs.fermion.app/creating-io-coding-labs/embed-lab

Learn how you can create IO coding labs inside Fermion interface and embed them externally

This article discusses integrating an IO coding lab externally on your website.

## How to embed a coding lab from Fermion?

Before starting the embed process, you need two things:

1. A school on Fermion
2. Fermion API key

## Getting lab ID

Go to `Manage features` from your instructor dashboard and enable `Coding labs` if you haven't done that yet.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/18-02-2025/screenshot-001199%402x.xuretn.png)

Once done, open `Coding lab` from sidebar and create a new IO lab.

Click on the `Embed` button to obtain the ID of that lab.

## Generating JWT

On any page in which you wish to let the user attempt the lab, you need to embed an iframe as follows:

```xml theme={null}
<iframe
	width="1280"
	height="720"
	src="https://acme.fermion.app/embed/io-coding-lab?token=EMBED_TOKEN_HERE"
	title="Coding Lab"
	frameborder="0"
	allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope;
	picture-in-picture; web-share"
	referrerpolicy="strict-origin-when-cross-origin"
	allowfullscreen>
</iframe>
```

Here, the `EMBED_URL` needs to be securely generated on your backend as follows:

<Steps>
  <Step title="Start with the base embed URL">
    The embed URL will always contain the following base: [`https://acme.fermion.app/embed/io-coding-lab?token=TOKEN_HERE`](https://acme.fermion.app/embed/io-coding-lab?token=TOKEN_HERE)
  </Step>

  <Step title="Generate a JWT with required claims">
    Generate a JWT (JSON Web Token) containing the following claims. The JWT token must be signed with your Fermion API Key.

    <ul>
      <li><code>labId</code> (String) – This is the unique identifier of the lab as mentioned above.</li>
      <li><code>userId</code> (String) – This is a string that you have stored in your database that can uniquely identify a given user. You have to ensure that you store this identifier properly in your database and reuse it every time a user tries to access any lab.</li>
      <li><code>isReadOnly</code> (Boolean, optional) – Set to <code>true</code> to render the embedded coding lab in a read-only mode. Defaults to <code>false</code>.</li>
    </ul>
  </Step>

  <Step title="Append the JWT to get the final URL">
    Append this generated JWT token to the end of the base URL to get the final embed URL
  </Step>
</Steps>

Example JavaScript code to generate `EMBED_URL` securely on your backend server:

This example uses the [jsonwebtoken package](https://www.npmjs.com/package/jsonwebtoken) to generate a JWT Token.

```js theme={null}
import jwt from 'jsonwebtoken'

const jwtToken = jwt.sign(
	{
		labId: '66a9202ab1458d00083ff520',
		userId: '<enter a user ID here unique to every user>',

		// change this to `true` to render the embedded coding lab in a read-only mode
		isReadOnly = false


	},
	'FERMION_API_KEY',
	{ expiresIn: '1h' }
)

const EMBED_URL =
	'https://example.fermion.app/embed/io-coding-lab?token=' +
	encodeURIComponent(jwtToken)
```

## How can I access lab results?

### Public API

We have an OpenAPI-spec compliant public API you can use, once you have access to FERMION\_API\_KEY. You can use this API to query multiple data points for your organization.

Please check the [API documentation here](https://api.fermion.app).

## Have a doubt?

In case something doesn’t work right, or you have any doubt, please feel free to reach out to us at [support@codedamn.com](mailto:support@codedamn.com) with your query, we’d be happy to resolve it at the earliest.


# Introduction
Source: https://docs.fermion.app/creating-io-coding-labs/introduction

An overview of IO-based coding labs designed for algorithmic and DSA-style coding exercises. Also learn about languages supported on Fermion.

Fermion’s IO Coding Labs provide an interactive environment for solving algorithmic and data structure–based challenges. These labs are designed to evaluate a learner’s ability to read input, process it through logic, and produce the correct output under defined constraints, just like in real competitive coding or technical interview settings.

Each coding lab runs securely in an isolated environment with configurable runtime limits for CPU, memory, and execution time. Learners can write, compile, and execute code directly in the browser while instructors receive precise insights into submission results, runtime performance, and test case accuracy.

![IO Coding Labs](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-10-2025/chrome_chAUaakdPP.ydaugn.png)

Fermion allows you to add IO coding labs. IO coding labs are powerful labs that can run the following languages:

<Check>
  Before you start, make sure **Coding labs** are enabled under **Manage Features** in your instructor dashboard. Learn how to enable features at Fermion [here](/manage-settings/manage-features)
</Check>

<Columns>
  <Card title="C / C++" icon="C" />

  <Card title="Java" icon="java" />

  <Card title="Python" icon="python" />

  <Card title="Node.js (JavaScript)" icon="node-js" />

  <Card title="SQLite / MySQL 8" icon="database" />

  <Card title="Go (1.19)" icon="golang" />

  <Card title="Rust (1.87)" icon="rust" />

  <Card title=".NET 8" icon="hashtag" />
</Columns>

IO coding labs are available to be used within the platform directly, or by embedding it.

<Info>
  Reach out to Fermion support if you need access to more runtimes than listed
  here.
</Info>

## How to access and create IO labs

<Steps>
  <Step title="Head over to the Coding Labs section">
    To access **IO Coding Labs**, go to your **Instructor Dashboard** and open the **Coding Labs** section from the sidebar. Click on **Labs** and then navigate to the **IO Coding Labs** tab.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/chrome_2hExtgjuiu.jvhizt.png)
  </Step>

  <Step title="Create a new lab">
    Give your lab a suitable **name** and click **Create Lab**.\
    Next, add a **title** and **description** for your lab. You can also use **[Fermion Copilot](/creating-io-coding-labs/ai-agent)** to help build your lab.\
    The description field supports **Markdown**, allowing you to format content and add details freely.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/chrome_VrsPm9w5ck.adkiai.png)
  </Step>

  <Step title="Add test cases">
    After creating the lab, move on to **adding test cases**.\
    You can include **sample test cases** as well, which will be visible to the users attempting the lab.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/chrome_uxQBfuaxeY.bpkifh.png)
  </Step>

  <Step title="Select supported languages">
    Choose the programming **language(s)** you want your learners to use in the lab. To configure the **default code template** for any language, click on the **arrow** next to the language name.\
    Learn how to create [SQL labs](/creating-io-coding-labs/sql-lab)
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/chrome_4Snrg7zXOs.rfeoii.png)
  </Step>

  <Step title="Set matcher type">
    Under **Matcher Type**, decide how the system should compare user output with the expected output:

    <Accordion title="Matcher type">
      Define how the expected output and user’s output should be compared:

      * **Exact match**: Character-by-character comparison
      * **Ignore whitespace at start and end**
      * **Ignore case sensitivity and whitespace at start and end**
      * **Ignore whitespace in every line at start and end**
      * **Ignore case  sensitivity and whitespace in every line at start and end**
    </Accordion>
  </Step>

  <Step title="Configure advanced settings">
    Under **Advanced Settings**, you can fine-tune your lab’s execution limits.\
    These defaults are usually optimal:

    * **Maximum CPU time (ms):** 2000
    * **Maximum wall time (ms):** 5000
    * **Maximum memory (KB):** 512000

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/31-10-2025/chrome_2CxWKgub2Q.fgqada.png)
  </Step>

  <Step title="Save your lab">
    Once all configurations are complete, click **Save Changes**.\
    Your IO Coding Lab is now successfully added and ready for learners!
  </Step>
</Steps>


# SQL Labs
Source: https://docs.fermion.app/creating-io-coding-labs/sql-lab

Learn how to setup a successful SQL coding lab on Fermion for your students

Fermion supports both SQLite and MySQL 8 for creating interactive SQL coding labs. This allows you to create hands-on database exercises where students can practice writing SQL queries against a real database.

## Prerequisites

Before creating a SQL lab, you'll need:

1. **For SQLite**: A SQLite database file (`.sqlite` format) named `db.sqlite`
2. **For MySQL 8**: A plaintext SQL file (`.sql` format) named `setup.sql`
3. The file should be compressed into a ZIP archive

## How to create SQLite lab?

Follow the steps below for setting up SQLite based lab:

### 1. Create Your Database File

First, create your SQLite database with the tables and data you want students to work with. You can either:

**Option A: Use an existing SQLite database**
You can use popular sample databases like:

* `chinook.db` - Music store database
* `northwind.db` - Business database
* `sakila.db` - DVD rental database

These are standard SQLite database files with `.db` extension that contain realistic data for learning purposes.

**Option B: Convert a plaintext SQL file to SQLite**
If you have a `.sql` file with CREATE TABLE and INSERT statements, you can convert it to an SQLite database:

1. **Using command line:**

```bash theme={null}
# Create database from SQL file
sqlite3 mydatabase.db < schema.sql

# Or if you want to create db.sqlite specifically
sqlite3 db.sqlite < schema.sql
```

2. **Using SQLite command line:**

```bash theme={null}
# Start SQLite
sqlite3 db.sqlite

# Read and execute SQL file
.read schema.sql

# Exit SQLite
.quit
```

3. **Using Python (if you prefer):**

```python theme={null}
import sqlite3

# Create database
conn = sqlite3.connect('db.sqlite')
cursor = conn.cursor()

# Read and execute SQL file
with open('schema.sql', 'r') as file:
    sql_script = file.read()
    cursor.executescript(sql_script)

conn.commit()
conn.close()
```

### 2. Prepare Your Database File

1. Save your database as `db.sqlite`
2. Create a ZIP archive containing only the `db.sqlite` file
3. The ZIP file should be named something descriptive like `student_database.zip`

## How to create MySQL 8 lab?

Follow the steps below for setting up MySQL 8 lab:

### 1. Create Your SQL Setup File

For MySQL 8 labs, you need to create a plaintext SQL file that contains all the necessary setup commands:

```sql theme={null}
-- Example setup.sql file
CREATE DATABASE IF NOT EXISTS student_db;
USE student_db;

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO users (name, email) VALUES
    ('John Doe', 'john@example.com'),
    ('Jane Smith', 'jane@example.com'),
    ('Bob Johnson', 'bob@example.com');

-- Add more tables and data as needed
```

### 2. Prepare Your SQL File

1. Save your SQL setup file as `setup.sql`
2. Create a ZIP archive containing only the `setup.sql` file
3. The ZIP file should be named something descriptive like `mysql_student_database.zip`

## Creating the SQL Lab on Fermion

<Note>
  If you have not enabled Coding labs, please go to "Manage features" >
  "Coding Labs" and enable that first from your instructor dashboard
</Note>

1. Navigate to your instructor dashboard
2. Go to the "Coding Labs" section
3. Click on "I/O labs" and create an SQL lab as IO lab
4. Edit this lab

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/29-07-2025/screenshot-002425.wlqwcm.png)

5. Inside the lab setup interface, scroll down and pick "SQL Lab".
6. Fermion currently supports SQLite and MySQL 8 as backend adapters for running SQL queries.
7. Expand this and upload the ZIP file you just created:
   * **For SQLite**: Upload `student_database.zip` containing `db.sqlite`
   * **For MySQL 8**: Upload `mysql_student_database.zip` containing `setup.sql`

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/29-07-2025/screenshot-002426.kvehag.png)

8. You can also add default starting code for students if required.

## Setting up test cases

For SQL labs, you can define a single test case where you write an expected output the query should produce.

### SQLite Test Cases

SQLite is able to produce output in 14 different formats, however Fermion outputs the SQL query output in `list` mode.

This is how list mode output works:

```bash theme={null}
sqlite> select * from tbl1;
hello!|10
goodbye|20
sqlite>
```

To get the expected output for your own query against your own database, create a file called `script.sql` that has the solution query, and run the following command locally on your system:

```bash theme={null}
cat script.sql | sqlite3 db.sqlite
```

### MySQL 8 Test Cases

For MySQL 8, the output format is similar to the standard MySQL command line output. To get the expected output for your query, you can run it locally against your MySQL database:

```bash theme={null}
mysql -u username -p database_name < script.sql
```

This will give you output of your command which you can copy-paste in the "output" box of test case.

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/29-07-2025/screenshot-002427.hykhoa.png)

Save your lab and try it as a user to see.

<Tip>
  Fermion runs every query in a completely isolated environment. Therefore,
  you can setup labs that can have INSERT or DELETE operations as well,
  alongside SELECT operations
</Tip>


# Executing SQLite via API
Source: https://docs.fermion.app/creating-io-coding-labs/sql-over-api

Learn how to execute SQLite code using Fermion DSA API, including preparing your database file and encoding it correctly.

SQL execution requires a small extra step compared to other languages: you need to upload a database file (`db.sqlite`), encoded as base64URL `string`, as part of your request.

This guide will walk you through everything: from preparing your `.sqlite` file to encoding and sending it through the API.

***

## What is SQLite

SQLite is a lightweight, self-contained, and serverless relational database engine.Unlike traditional database management systems, it does not require a separate server process, making it ideal for applications that need an embedded database with minimal setup.

SQLite stores the entire database, including tables, indexes, and data, in a single `.sqlite` file, which makes it highly portable and easy to distribute.

It supports standard SQL syntax, transactions, and most common database features, allowing you to run queries,
insert data, and perform updates directly within the database file.
Its simplicity and reliability have made SQLite widely used in desktop applications, mobile apps, and embedded systems.

Head over to [SQLite org](https://sqlite.org/index.html) to learn more about SQLite

## How to execute SQL over Fermion API

Fermion offers the ability to execute SQL queries over the API. You can utilize the following steps to execute SQLite queries:

<Steps>
  <Step title="Create a sample SQLite database">
    Create a simple SQLite database and populate it with sample data. Note that this is just a sample schema and you can write your own schema
    as per the [SQLite guide](https://sqlite.org/lang.html)

    ```sql theme={null}
    -- schema.sql
    CREATE TABLE users (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      name TEXT NOT NULL,
      email TEXT UNIQUE NOT NULL
    );

    INSERT INTO users (name, email) VALUES
    ('Alice', 'alice@fermion.app'),
    ('Bob', 'bob@fermion.app'),
    ('Charlie', 'charlie@fermion.app');

    -- Add more tables and data as needed
    ```

    If you have [sqlite3](https://sqlite.org/index.html) installed, you can run this locally using sqlite3 to convert your `sql` schema into an `sqlite` file:

    ```bash theme={null}
    sqlite3 db.sqlite < schema.sql
    ```

    You can also utilize **python** scripts to convert your `schema.sql` file into a `db.sqlite` file.

    ```python theme={null}
    import sqlite3

    # Create database
    conn = sqlite3.connect('db.sqlite')
    cursor = conn.cursor()

    # Read and execute SQL file
    with open('schema.sql', 'r') as file:
      sql_script = file.read()
      cursor.executescript(sql_script)

    conn.commit()
    conn.close()
    ```
  </Step>

  <Step title="Prepare Files for API Request">
    The Fermion API requires:

    * A ZIP file containing your `db.sqlite` file (Base64URL encoded)

    Here’s a simple script to generate base64URL encodings in Python for your zip file. Make sure to have a `db.sqlite` file in the same folder when you run this script

    ```python theme={null}
    import base64
    import zipfile

    def base64url_encode(data: bytes) -> str:
      # Base64 URL-safe encoding without padding
      return base64.urlsafe_b64encode(data).decode("utf-8").rstrip("=")

    # Create a ZIP containing db.sqlite
    zip_filename = "db.zip"
    with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_DEFLATED) as zipf:
      zipf.write("db.sqlite", arcname="db.sqlite")  # must be exactly 'db.sqlite'

    print(f"{zip_filename} created successfully!")

    # Read ZIP bytes
    with open(zip_filename, "rb") as f:
      zip_bytes = f.read()

    # Base64URL encode
    encoded_zip = base64url_encode(zip_bytes)

    # Save encoded string to file
    with open("encoded.txt", "w") as f:
      f.write(encoded_zip)

    print("Base64URL encoded string saved to encoded.txt")
    ```

    This script will provide you with a `db.zip` file and another file called `encoded.txt`, which will have the `base64URL` encoded string of the db.zip file.

    <Warning>
      The ZIP must **contain exactly one file named `db.sqlite`** : the API expects this name. Do not rename it to anything else inside the ZIP archive.
    </Warning>

    You can utilize this string while making the API request.
  </Step>

  <Step title="Make the API Request">
    Once you have the encoded SQL and ZIP file, you can now execute SQL queries via the [Request DSA code execution \[batch\]](/api-reference/dsa/get-dsa-code-execution-result-\[batch]) endpoint.
    Note that you also have to base64URL encode the source code and add the encoded string to the request for the `sourceCodeAsBase64UrlEncoded` property

    You can take help of the following json schema while setting up your own requests for SQL executions.

    ```json theme={null}
    {
      "language": "Sqlite_3_48_0",
      "sourceCodeAsBase64UrlEncoded": "<your-sql-query-base64url>",
      "additionalFilesAsZip": {
        "type": "base64url-encoding",
        "base64UrlEncodedZip": "<your-db-zip-base64url>"
      },
      "runConfig": {
        "callbackUrlOnExecutionCompletion": "https://your-domain.com/webhook/sqlite-result",
        "expectedOutputAsBase64UrlEncoded": "<string>",
        "customMatcherToUseForExpectedOutput": "ExactMatch",
        "cpuTimeLimitInMilliseconds": 2000,
        "wallTimeLimitInMilliseconds": 5000,
        "memoryLimitInKilobyte": 512000
      }
    }
    ```

    This `POST` request will return a list of task IDs which you can utilize while retrieving the execution results.

    ```json theme={null}
    {
      "output": {
        "status": "ok",
        "data": {
          "taskIds": [ "<string>" ]
        }
      }
    }
    ```
  </Step>

  <Step title="SQLite test cases">
    SQLite can produce output in multiple formats (up to 14), but **Fermion’s API uses the `list` mode format** for evaluating SQL output.

    In list mode, each column value is separated by a `|` (pipe), and each row appears on a new line.\
    Here’s an example:

    ```bash theme={null}
    sqlite> SELECT * FROM users;
    Alice|alice@fermion.app
    Bob|bob@fermion.app
    Charlie|charlie@fermion.app
    sqlite>
    ```

    To get the expected output for your own query against your own database,
    create a file called script.sql that has the solution query, and run the following command locally on your system:

    ```bash theme={null}
    cat script.sql | sqlite3 db.sqlite
    ```

    This command will print the output in the same list format that Fermion expects.
    You can then take this exact output, encode it using Base64URL, and include it in your API request under:

    ```json theme={null}
    "expectedOutputAsBase64UrlEncoded": "<base64url-of-your-expected-output>"
    ```
  </Step>

  <Step title="Retrieve results">
    You can utilize the task IDs received above to retrieve the results of DSA code execution

    * Poll results via [Get DSA code execution result \[batch\]](/api-reference/dsa/get-dsa-code-execution-result-\[batch])
    * Receive a webhook automatically if you specified `callbackUrlOnExecutionCompletion` Learn more about this [here](/creating-io-coding-labs/api-usage#using-webhook-urls-for-instant-results-recommended)

    A successful response will look like:

    ```json theme={null}
    {
      "output": {
        "status": "ok",
        "data": {
          "tasks": [
            {
              "taskUniqueId": "<string>",
              "sourceCodeAsBase64UrlEncoded": "<string>",
              "language": "C",
              "runConfig": {
                  // your runConfig for this taskID
              },
              "codingTaskStatus": "Pending",
              "runResult": {
                "compilerOutputAfterCompilationBase64UrlEncoded": "<string>",
                "finishedAt": "2023-11-07T05:31:56Z",
                "runStatus": "compilation-error",
                "programRunData": {
                  "cpuTimeUsedInMilliseconds": 1,
                  "wallTimeUsedInMilliseconds": 1,
                  "memoryUsedInKilobyte": 1,
                  "exitSignal": 123,
                  "exitCode": 123,
                  "stdoutBase64UrlEncoded": "<any>",
                  "stderrBase64UrlEncoded": "<any>"
                }
              }
            }
          ]
        }
      }
    }
    ```
  </Step>
</Steps>

## Best practices

* Ensure the ZIP file only contains **`db.sqlite`** , not folders or other files.
* Always use **Base64URL**, not standard Base64.

***


# Submissions
Source: https://docs.fermion.app/creating-io-coding-labs/submissions

Learn how to view and track submission history for IO coding labs

The Submissions History feature allows learners to view all their past code submissions for an IO coding lab, including execution results, performance metrics, and test case outcomes.

## How to access Submissions History

<Steps>
  <Step title="Navigate to Coding Labs">
    Go to your **Instructor Dashboard** and open the **Coding Labs** section from the sidebar. Click on **Labs** and then navigate to the **IO Coding Labs** tab.
  </Step>

  <Step title="Open a lab">
    Select any IO coding lab from your list to open it.
  </Step>

  <Step title="Try out the lab">
    Click on **Try out lab** to open the lab in the coding interface.
  </Step>

  <Step title="View submission history">
    Click on **Submission history** in the lab interface to view all your past submissions for that lab.
  </Step>
</Steps>

![Submissions History](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_AaUbmn1mMz.ykxhsp.png)

## Understanding the Submissions Table

The Submissions History table displays comprehensive information about each code submission:

| Column         | Description                                                             |
| -------------- | ----------------------------------------------------------------------- |
| **DATE**       | The date and time when the submission was made                          |
| **STATUS**     | The overall result of the submission (e.g., Full Correct, Wrong Answer) |
| **LANGUAGE**   | The programming language used for the submission                        |
| **RUNTIME**    | The execution time of the code in milliseconds                          |
| **MEMORY**     | The memory consumed during code execution                               |
| **TEST CASES** | The number of test cases passed (e.g., 1/1, 0/1)                        |

## Submission Status Types

Each submission displays a status that indicates the outcome of the code execution:

<Columns>
  <Card title="Full Correct" icon="check-circle">
    All test cases passed successfully. The solution is correct.
  </Card>

  <Card title="Wrong Answer" icon="times-circle">
    The code executed successfully but produced incorrect output for one or more test cases.
  </Card>
</Columns>

## Viewing Submission Details

Click on any submission entry in the table to view detailed information about that specific submission, including:

* Complete source code that was submitted
* Individual test case results
* Execution logs and error messages (if any)
* Performance metrics breakdown

<Info>
  Submissions History helps learners track their progress, identify patterns in
  their solutions, and learn from previous attempts.
</Info>

<Tip>
  Instructors can also view submission history for all learners from the lab
  management interface to monitor class progress and identify common issues.
</Tip>

***

<Note>
  This feature was introduced in November 2025. For more product updates, see
  the [Product Updates](/changelog) page.
</Note>


# Blogs
Source: https://docs.fermion.app/custom-landing-pages/blogs

Create and manage blogs easily within Fermion to share updates, tutorials, and stories with your audience.

Blogs in Fermion are a powerful way to share knowledge, updates, tutorials, or announcements with your audience. Whether you want to post educational content for your students, share organizational news, or highlight success stories, blogs provide a structured and visually appealing way to communicate.

Each blog supports Markdown formatting, allowing you to style your text, include images, and even add code snippets. Additionally, SEO settings like custom URL slugs and categories help your blogs reach a wider audience, while thumbnails and categories make it easier for readers to discover and navigate your content.

<Check>
  Blogs are hosted directly on your **domain**, so your learners and audience can read them without visiting any third-party platform. This ensures a complete branded experience while keeping all your content centralized.
</Check>

## How blogs differ from in-course articles

Unlike in-course articles, which are tied to a specific course and can only be accessed by learners enrolled in that course, blogs in Fermion are standalone content pieces that live on your own domain. This means they can be shared publicly across the internet, making it easy for anyone to discover and read them.

Blogs give you the flexibility to reach a wider audience, showcase your expertise, promote courses or resources, and share updates or educational content in a professional, branded way.

## How to create a blog?

Creating a blog in Fermion is quick and easy. Follow these steps to publish your first article:

<Steps>
  <Step title="Enable blogs in manage features">
    Before creating blogs, make sure the **Blogs** feature is enabled in your workspace.\
    You can do this from the **Manage Features** section.\
    [Learn how to manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Navigate to blogs section">
    Go to your **Instructor Dashboard → Blogs**.\
    Click on **Create a new blog** to open the blog builder.
    ![Create new blog](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/create%20new%20blog.oauffx.png)
  </Step>

  <Step title="Add blog title and content">
    Enter your **Blog Title** at the top.\
    Use the **editor** below to write your blog content. The rich text editor supports **Markdown syntax**, so you can format text, add images, and insert code blocks easily.
  </Step>

  <Step title="Add SEO details">
    In the **Blog Settings** pane on the right, you can:

    * Upload a **Thumbnail Image**.
    * Add a **URL Slug** and add a **Category** under **SEO Settings**.
    * Click **Save SEO Settings** once done.

    ![Create the blog](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/build%20blog.zdxtky.png)
  </Step>

  <Step title="Save and publish">
    After reviewing your blog, click **Save changes** in the top-right corner to save your work.\
    Once saved, click on the **Publish blog** button right next to the save button to publish your blog. You can now copy the blog link and share it!
  </Step>
</Steps>

## Access blogs over API

You can also manage and retrieve blogs programmatically using Fermion's API. The following endpoints are available:

<Columns>
  <Card title="Get all published blogs">
    Retrieve a list of all blogs that have been published. Use this endpoint to display blogs on your website or app. [Learn more](/api-reference/blog/get-published-blogs)
  </Card>

  <Card title="Get information for a specific blog">
    Fetch detailed information about a single blog, including its title, content, SEO details, and thumbnail. [Learn more](/api-reference/blog/get-blog-information)
  </Card>
</Columns>

For full details, authentication requirements, and request examples, head over to the [API reference](/api-guide/introduction)


# Direct Checkout Links
Source: https://docs.fermion.app/custom-landing-pages/checkout-page-direct-links

Understand how to construct direct checkout page links using Fermion

When creating custom landing pages on Fermion, you can include direct checkout links that seamlessly redirect users to purchase your digital products or courses. This allows you to maintain full control over your landing page design while still leveraging Fermion's secure checkout system.

## How Checkout Links Work

Any anchor link or button with a redirect URL in the following format will open the Fermion checkout page:

```html theme={null}
/api/buy-digital-product?product-slug=YOUR_PRODUCT_SLUG
```

<Info>
  The checkout page is automatically generated by Fermion and includes all
  necessary payment processing, security measures, and user authentication.
</Info>

## URL Parameters

Fermion's checkout system supports several URL parameters to customize the checkout experience:

### Required Parameters

* **`product-slug`**: The slug of your digital product or course that you want users to purchase. This field is mandatory and cannot be omitted.

### Optional Parameters

* **`discount-code`**: Any discount code that needs to be automatically applied to the user's checkout session. The discount code must exist in your product's discounts section area. If the code doesn't exist or has expired, users will see an "Invalid discount code" warning but can still complete checkout at full price.

* **`digital-product-price-id`**: The specific price ID for the digital product, useful if you have multiple pricing plans.

* **`total-installments-count`**: The number of installments for partial payment plans. Only required if the selected plan is an installment plan.

* **`prefilled-name`**: Pre-fills the user's name on the checkout form. Useful when your landing page collects user input.

* **`prefilled-email`**: Pre-fills the user's email address on the checkout form. Useful when your landing page collects user input.

* **`prefilled-phone-number`**: Pre-fills the user's phone number on the checkout form. Useful when your landing page collects user input.

* **`smart-checkout-redirect`**: Set to `true` to automatically redirect to the best available payment gateway when `prefilled-email` and `prefilled-name` are present. This reduces one step for users to complete.

* **UTM Parameters**: For marketing attribution, you can add any of the following:

* `utm_source`, `utm_medium`, `utm_campaign`, `utm_id`, `utm_term`, `utm_content`

<Warning>
  Make sure to properly encode all parameter values to avoid breaking the
  checkout flow. Special characters in names, emails, or discount codes must
  be URL-encoded.
</Warning>

## Code Examples

### Basic Checkout Link

```html theme={null}
<a href="/api/buy-digital-product?product-slug=my-awesome-product">
	Buy My Product
</a>
```

### Checkout Link with Discount Code and UTM Parameters

```html theme={null}
<a
	href="/api/buy-digital-product?product-slug=my-awesome-product&discount-code=EARLY_LAUNCH&utm_source=newsletter&utm_medium=email"
>
	Buy with Early Bird Discount
</a>
```

### Checkout Link with Pre-filled Information and Installments

```html theme={null}
<a
	href="/api/buy-digital-product?product-slug=my-awesome-product&digital-product-price-id=price_123&total-installments-count=3&prefilled-name=John%20Doe&prefilled-email=john@example.com"
>
	Buy Product (3 Installments)
</a>
```

### Complete Checkout Link with All Parameters

```html theme={null}
<a
	href="/api/buy-digital-product?product-slug=my-awesome-product&digital-product-price-id=price_123&total-installments-count=3&discount-code=EARLY_LAUNCH&prefilled-name=John%20Doe&prefilled-email=john@example.com&prefilled-phone-number=1234567890&smart-checkout-redirect=true&utm_source=adwords&utm_medium=cpc&utm_campaign=summer_sale"
>
	Buy Product Now
</a>
```

## JavaScript Implementation

For dynamic checkout links that collect user input from your landing page, use this JavaScript function to safely construct the checkout URL:

```javascript theme={null}
function initiateCheckout() {
	// Assuming this function is called on a button click
	const params = new URLSearchParams({
		'discount-code': code,
		'product-slug': checkoutPageDataInfo.fermionDigitalProductSlug,
		'digital-product-price-id':
			checkoutPageDataInfo.pricingPlanSpecificData
				.fermionDigitalProductPriceId,
		'total-installments-count':
			checkoutPageDataInfo.pricingPlanSpecificData.planType ===
			'PartialPaymentPlan'
				? (
						checkoutPageDataInfo.pricingPlanSpecificData
							.installmentCountSelectedByUser ?? ''
				  ).toString()
				: '',
		'prefilled-name': nameOfUser || '',
		'prefilled-email': emailOfUser || '',
		'prefilled-phone-number': phoneNumber || '',
		'smart-checkout-redirect': 'true',
		utm_source: utmSource || '',
		utm_medium: utmMedium || '',
		utm_campaign: utmCampaign || '',
		utm_id: utmId || '',
		utm_term: utmTerm || '',
		utm_content: utmContent || '',
	})

	// Remove empty parameters
	params.forEach((value, key) => {
		if (value === '') params.delete(key)
	})

	window.location.href = `/api/buy-digital-product?${params.toString()}`
}
```

<Tip>
  The JavaScript approach using `URLSearchParams` automatically handles URL
  encoding, making it the safest way to construct checkout links with user
  input.
</Tip>

## Manual URL Construction

If you prefer to construct URLs manually, ensure you use `encodeURIComponent()` for all parameter values:

```javascript theme={null}
const productSlug = 'my-awesome-product'
const priceId = 'price_123'
const installmentCount = '3'
const userName = 'John Doe'
const userEmail = 'john@example.com'
const utmSource = 'newsletter'

const checkoutUrl = `/api/buy-digital-product?product-slug=${encodeURIComponent(
	productSlug
)}&digital-product-price-id=${encodeURIComponent(
	priceId
)}&total-installments-count=${encodeURIComponent(
	installmentCount
)}&prefilled-name=${encodeURIComponent(
	userName
)}&prefilled-email=${encodeURIComponent(
	userEmail
)}&utm_source=${encodeURIComponent(utmSource)}`
```

<Danger>
  Failing to properly encode parameter values can break the checkout flow,
  especially when dealing with special characters in names, emails, or
  discount codes.
</Danger>

## Integration with Custom Landing Pages

To integrate checkout links with your custom landing pages:

1. **Create your custom page** in Fermion's instructor dashboard
2. **Design your landing page** with HTML, CSS, and JavaScript
3. **Add checkout buttons/links** using the `/api/buy-digital-product` URL format
4. **Test the checkout flow** to ensure all parameters work correctly
5. **Publish your page** when ready

<Check>
  Your custom landing page will maintain full design control while seamlessly
  integrating with Fermion's secure checkout system.
</Check>

## Best Practices

* **Always test checkout links** before publishing your landing page
* **Use the JavaScript approach** when collecting user input to ensure proper encoding
* **Keep discount codes simple** and avoid special characters when possible
* **Validate user input** before constructing checkout URLs
* **Provide fallback options** in case discount codes are invalid or expired
* **Use UTM parameters** to track marketing attribution and campaign performance

<Note>
  The checkout page automatically handles payment processing, user
  authentication, and product access management, so you can focus on creating
  compelling landing pages that drive conversions.
</Note>


# Custom Redirects
Source: https://docs.fermion.app/custom-landing-pages/custom-redirects

Set up custom redirects to guide learners to specific pages, courses, or resources efficiently.

Custom redirects are a powerful URL management system that gives you complete control over how URLs are redirected within your platform. They enable you to establish rules for automatically directing users from one URL to another, ensuring a seamless browsing experience while maintaining the integrity of your website's navigation structure.

Custom redirects give you complete control over URL redirections within your platform so you can easily maintain and manage URL structures.

They are particularly useful for updating URLs while maintaining existing links, creating shorter paths to specific pages, and managing seasonal or temporary redirects, all while ensuring seamless navigation after content restructuring.

## Why use custom redirects?

Website structures rarely remain static. As your site grows and evolves, you'll likely need to reorganize content, update URL structures, or create more intuitive paths to important pages. Custom redirects are essential during these transitions, preventing broken links and maintaining your site's SEO value. They're particularly valuable when you're rebranding, restructuring your content hierarchy, or running temporary promotional campaigns that require special URL handling.

## When to use custom redirects?

You can use custom redirects in the following scenarios:

* Content Restructuring:
  When you're reorganizing your website's content hierarchy, custom redirects ensure that users following old bookmarks or links still reach their intended destination. This is crucial for maintaining user experience and preventing frustration from encountering 404 errors.

* SEO Preservation:
  If you've built up SEO value on existing URLs, redirects help transfer that authority to new pages, preventing loss of search engine ranking when you need to change URL structures.

* Marketing Campaigns:
  During seasonal promotions or temporary campaigns, you might want to create simple, memorable URLs that redirect to specific landing pages. Custom redirects make this possible without permanently altering your site's structure.

* Brand Consolidation:
  When merging multiple websites or consolidating content from different domains, custom redirects help create a unified navigation structure while ensuring old links continue to work.

## How to use custom redirects on Fermion?

With custom redirects on Fermion you can:

* Create exact path matches for precise URL control or create wildcard matches.
* Set up static pathname or URL redirects
* Manage multiple redirects from a central dashboard
* Instant publishing and unpublishing capabilities

### Step 1:

Navigate to the `custom redirects` tab from your Fermion dashboard.

![djfbkjdbnfkjd](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/50%402x.xueuds.png)

### Step 2:

Click on "Create" to create a new custom redirect.

![dfdfd](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/57%402x.yxaxxj.png)

### Step 3:

Setup your custom redirect.

![dfddddfd](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/44%402x.ikixyz.png)

* When setting up custom redirects, prioritize exact path matches for precise control over specific URLs.
* Use wildcard matches judiciously for handling groups of similar URLs that should all follow the same redirection pattern.
* Always test your redirects thoroughly before publishing, and monitor their performance to ensure they're serving their intended purpose.

### Step 4:

Publish your custom redirect.

![dfddddfd](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/55%402x.mxqzni.png)


# Introduction
Source: https://docs.fermion.app/custom-landing-pages/introduction

Learn how to create high-converting, fully customizable landing pages on Fermion using no-code tools or your own source code.

Creating a custom landing page on Fermion empowers you to capture your audience’s attention, drive targeted campaigns, and boost conversions for your brand or educational offerings.

* Create tailored landing pages for different campaigns or audiences
* Track metrics like conversion rate and bounce rate
* Deliver a unique brand experience

## What is a custom page?

A custom page on Fermion is a fully user-controlled page. You can either write and upload your own HTML/CSS/JS, or use a no-code tool like WordPress to design your page visually. Fermion will host and serve your page exactly as you design it.

## How to create a custom page in Fermion

Fermion allows you to create fully customizable landing pages by uploading your own source code. This gives you complete control over the design, layout, and functionality of your page.

* **Static website upload:** Develop your page using HTML, CSS, and JavaScript with your preferred tools. Once ready, upload the source code to Fermion.
* Fermion will host and serve your page exactly as you designed it, ensuring your custom styles, scripts, and interactions work flawlessly.
* You can update your page anytime by uploading new versions of your source code, making it easy to iterate and improve your landing pages.

The following sections will guide you step-by-step through uploading and managing your custom landing page on Fermion.

## Next steps

<Columns>
  <Card title="Using AI Builder" href="/custom-landing-pages/using-ai-builder">
    Create professional landing pages in minutes using Fermion's AI Builder. Simply describe what you want, and the AI will generate a complete page for you.
  </Card>

  <Card title="Source code landing pages" href="/custom-landing-pages/using-source-code">
    Learn how to create fully customizable landing pages on Fermion by uploading your own HTML, CSS, and JavaScript source code.
  </Card>

  <Card title="Blogs on Fermion" href="/custom-landing-pages/blogs">
    Discover how to create, manage, and publish engaging blog content to connect with your audience and share your expertise.
  </Card>
</Columns>


# Using AI Builder
Source: https://docs.fermion.app/custom-landing-pages/using-ai-builder

Learn how to create custom pages using Fermion's AI builder to generate and customize pages with real-time data and checkout links

Fermion's AI Builder allows you to create fully customized pages by simply describing what you want. The AI will generate a complete page for you, which you can then refine with real-time data, direct checkout links, and custom paths.

This powerful no-code tool eliminates the need for manual HTML/CSS/JavaScript coding, making it easy for anyone to create professional landing pages in minutes.

## How AI Builder Works

The AI Builder uses advanced language models to understand your requirements and generate complete, functional landing pages. You can:

* Describe your page in natural language
* Let the AI generate the complete page structure and design
* Refine the page with real-time data integration
* Add direct checkout links with proper interlinking
* Customize the page path and publish instantly

<Steps>
  <Step title="Navigate to Custom Pages">
    From your instructor dashboard, navigate to **Pages & redirects** and then click on **Custom pages**.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_3tKB6TZN7k.dqdikf.png)
  </Step>

  <Step title="Click on Edit Website with AI">
    Click on the **Edit website with AI** option to open the AI Builder interface.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_HNqOrJusqW.ewyljx.png)
  </Step>

  <Step title="Interact with the AI">
    Describe the type of landing page you want to create. You can specify:

    * The purpose of the page (e.g., course landing page, product sales page)
    * The design style you prefer
    * Key sections you want to include
    * Any specific features or elements

    The AI will understand your requirements and generate a complete static page structure.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_hXXDRgPZEn.ifwcmg.png)
  </Step>

  <Step title="Wait for AI to Build Your Page">
    The AI will process your request and generate a complete landing page. This may take a few moments as the AI creates all the necessary HTML, CSS, and JavaScript code.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_yz1KjFps7Q.wegjce.png)
  </Step>

  <Step title="Refine Your Page">
    Once the AI has generated your page, you can refine it by:

    * Adding real-time data integration
    * Adding direct checkout links with proper interlinking
    * Customizing the design and layout
    * Adjusting content and messaging

    <Info>
      You can add direct checkout links using the format `/api/buy-digital-product?product-slug=YOUR_PRODUCT_SLUG`. For more details on checkout links, see the [Direct Checkout Links](/custom-landing-pages/checkout-page-direct-links) guide.
    </Info>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_GAPd6HVxw3.upvqrr.png)
  </Step>

  <Step title="Add a Custom Path">
    Assign a custom path to your page (e.g., `/landingpage`, `/course-intro`, `/product-sales`). This will be the URL where your page will be accessible.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_AuD0P5KmUh.kbuaey.png)
  </Step>

  <Step title="Publish Your Page">
    Click on the **Publish** button to make your page live. Once published, your page will be accessible at the custom path you specified.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_AuD0P5KmUh.kbuaey.png)
  </Step>
</Steps>

## Managing Published Pages

Once your page is published, you can:

* **View the page**: Click to see how your page appears to visitors
* **Unpublish the page**: Temporarily remove the page from public access without deleting it
* **Edit the page**: Make further refinements and republish

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_0wgLmxa9D3.xerogj.png)

## Best Practices

* **Be specific in your AI prompts**: The more details you provide about what you want, the better the AI can generate your page
* **Test checkout links**: Always verify that direct checkout links work correctly before publishing
* **Review the generated code**: While the AI generates functional code, you may want to review and customize it further
* **Use meaningful paths**: Choose descriptive paths that reflect the purpose of your page
* **Iterate and refine**: Don't hesitate to ask the AI to make adjustments or regenerate sections

<Tip>
  The AI Builder is perfect for quickly prototyping landing pages. For more advanced customization, you can always export the generated code and modify it manually, or use the [Source Code](/custom-landing-pages/using-source-code) method for complete control.
</Tip>

## Next Steps

<Columns>
  <Card title="Direct Checkout Links" href="/custom-landing-pages/checkout-page-direct-links">
    Learn how to integrate direct checkout links into your AI-generated pages for seamless purchase flows.
  </Card>

  <Card title="Using Source Code" href="/custom-landing-pages/using-source-code">
    For advanced customization, learn how to upload and manage custom HTML/CSS/JavaScript source code.
  </Card>
</Columns>


# Using Source Code
Source: https://docs.fermion.app/custom-landing-pages/using-source-code

Learn how to create fully customized pages by adding source code directly for complete control over design and functionality

When creating custom pages on Fermion, you have the flexibility to upload and host your own static websites directly from source code.

This powerful feature allows you to deploy custom-built web applications, landing pages, or any other web content you've developed using modern web technologies.

This guide will walk you through the process of uploading your static website to Fermion, explain how assets are handled, and provide best practices for successful deployment.

## What are static websites?

A static website consists of HTML, CSS, JavaScript, and other assets that are pre-built and ready to serve to users. Unlike dynamic websites that generate content on-the-fly, static websites are pre-rendered, making them fast, secure, and easy to deploy.

## Supported technologies

Fermion can support any technology that can create a static export after building. This includes, but not limited to:

* Raw HTML/CSS/JS projects
* Next.js
* Remix
* React, Astro, etc. with Vite

## Asset hosting (CSS, JS, and other assets)

Fermion automatically hosts all static assets that are included in your build output, including:

* CSS files
* JavaScript files
* Images
* Fonts
* Other media files (videos, audio, etc.)

When you upload your ZIP file containing the build output, we automatically:

* Extract all assets from the ZIP file
* Upload them to our CDN (content delivery network)
* Make them available through your unique CDN prefix URL

<Tip>
  All assets must be included in your build output folder before zipping. Make
  sure your assets are properly optimized before building (compressed images,
  minified CSS/JS).
</Tip>

## How do custom webpages on Fermion work?

To understand that, check the image below:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/screenshot-000112%402x.lzitrw.png)

* You must upload one zip file of static export (this can be either raw HTML/CSS code, or generated by CLI commands like `next export` for example if you're using Next.js)
* All the HTML files you have in the zip file would automatically become pages on your website. For example, let's assume you have a domain called `myawesomewebsite.com` and you upload the ZIP file as shown above. Then you would have the following pages as custom pages:

  * `myawesomewebsite.com` homepage would be `index.html`
  * `myawesomewebsite.com/welcome-to-my-page` would be `welcome-to-my-page.html` (notice no `.html` at the end of the page)
  * `myawesomewebsite.com/hello/world.html` would be `hello/world.html` (notice no `.html` at the end of the page)

### What about static assets?

The static assets in this case (`style.css` and `my-dog.mp4`) would be hosted on a CDN instead of directly on your main domain (`myawesomewebsite.com`). This ensures less load on main host and faster website load times.

This means that instead of `myawesomewebsite.com/style.css` for loading the stylesheet, you would load it from `anotherdomain-cdnurl.com/.../style.css`. This other URL that you have to prefix will be provided to you based on the technology you use.

### Is it not a lot of manual work to replace CDN URL in my code for static assets?

Most modern frameworks like Next.js and Vite provide out of the box support for third party CDNs for static hosting at build time. All you have to do is follow the instructions as given below and it should work fine.

But yes, if you're hosting a custom HTML/CSS/JS build without any bundler, you must manually replace the links yourself.

## How can you upload a custom page?

Follow the steps below to understand how source-code hosting works on Fermion.

<Steps>
  <Step title=" Navigate to Pages & redirects">
    From your dashboard, navigate to `Pages & redirects`.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/32%402x.zmznlx.png)
  </Step>

  <Step title="Access Custom Pages">
    Click on `Custom pages` and go to the `Manage Fermion` section.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/58%402x.pmticb.png)
  </Step>

  <Step title="Choose your technology">
    Choose from available technologies.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/33%402x.kxgjgj.png)

    When building your static website on Fermion, you can choose from several modern web technologies. For simpler projects or custom implementations, you can use plain HTML/CSS/JavaScript.

    <Info>
      All these technologies will be properly hosted on Fermion with full asset support (CSS, JavaScript, images, etc.) through our CDN.
    </Info>

    For example: I'll be demonstrating the process by uploading a basic HTML website. So I will choose the `custom HTML website` option. Similarly, based on your requirements you can choose from available options of technologies.

    <Tip>
      Please note that this step is merely for demonstration purpose. It is not mandatory to choose the <code>custom HTML website</code> option. Please choose the option which suits the best for your needs.
    </Tip>

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/08%402x.wvlfvk.png)

    Once you have clicked on the option, you will see further instructions and details for deploying your website project. Note that these instructions are different for every technology.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/20%E2%80%AFPM.svvcxj.png)
  </Step>

  <Step title="Prepare your ZIP file">
    Prepare for the upload. Create a ZIP file containing your website files. All static assets (HTML, CSS, JavaScript, images) should be included in this ZIP file.
  </Step>

  <Step title="Upload your website">
    Upload your website by clicking the "Upload website ZIP file" button. The system will process your ZIP file and deploy it to the CDN.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/58%402x.eiirbe.png)

    <Warning>
      Fermion does **not** store your ZIP files. Once uploaded, your ZIP is **flattened and hosted alongside your school's assets**. This means it is difficult to recover old code after uploading. Make sure you retain a local copy of your files before deployment.
    </Warning>
  </Step>

  <Step title=" Configure static assets">
    Configure your static assets to use the CDN prefix URL. There are two ways to do this:

    * Update your base href tag in your HTML:
      `<base href="https://custom-webpage-static-assets-production.fermion.app/66467a43e44cda2c9f7ab7a9-custom-zip-pages/">`

    * Or prefix all your static asset URLs with the CDN URL:
      * Before: ./my-script.js
      * After: [https://custom-webpage-static-assets-production.fermion.app/66467a43e44cda2c9f7ab7a9-custom-zip-pages/my-script.js](https://custom-webpage-static-assets-production.fermion.app/66467a43e44cda2c9f7ab7a9-custom-zip-pages/my-script.js)
  </Step>

  <Step title="Verify publication">
    Once uploaded and configured, your page will be published and accessible. You can verify this by checking the status which should show as "Published" in the pages list.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/24-11-2024/59%402x.pldzlh.png)
  </Step>
</Steps>


# Downloadable Products
Source: https://docs.fermion.app/digital-products/downloadable-products

Learn how to design, upload, and publish your first downloadable product on Fermion

## Introduction

Downloadable products are digital files that your users can purchase or access directly from Fermion. These can include templates, guides, reports, software, compressed files or any other type of file you want to distribute digitally.

## Create a downloadable product

Creating your first **downloadable product** on Fermion is as easy as it can get. This guide walks you through the entire process: from setting up a dedicated landing page to uploading your digital file in the Product Builder. With Fermion, you can showcase your content professionally, control access, and offer secure downloads to your audience.

<Info>
  Before you start, make sure **Digital Products** are enabled under **Manage Features** in your instructor dashboard. This allows you to create and sell downloadable products on Fermion. Learn how to enable features [here](/manage-settings/manage-features)
</Info>

### Landing page

Your downloadable product’s landing page is where potential customers discover and purchase your content.

### Steps to create a landing page

<Steps>
  <Step title="Enable digital products">
    Before creating a downloadable product, you need to manually enable the Digital Products feature from your instructor dashboard. Learn more about how to [enable features](/manage-settings/manage-features)

    1. Head over to Manage Features.
    2. Enable the toggle for Digital Products.
  </Step>

  <Step title="Navigate to digital products">
    1. Go to your **Instructor Dashboard → Digital Products**.
    2. Select **Create new Product** if you want to create a new item or update an existing one by clicking **Open Product Builder**.\
       ![Access Digital Product](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/instructordashboarddigital.uthmpx.png)
  </Step>

  <Step title="Define product metadata">
    Navigate to the **Landing Page** tab in your product sidebar.\
    Add the essential details about your product:

    * **Product Title & Tagline:** Clearly describe your product and what buyers can expect.
    * **Thumbnail / Cover Image:** Upload a high-resolution image to make your product stand out.\
      ![Product Metadata](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/productmetadatad.zxqums.png)
  </Step>

  <Step title="Add product description">
    Write a compelling and informative description of your product.\
    The description editor supports **Markdown**, so you can format text, create bullet points, add links, and emphasize content.\
    ![Product Description](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/enterdescription.jtbjdh.png)
  </Step>

  <Step title="Upload product file">
    Upload your product file (.HTML, .ZIP, or other supported formats).

    ![Upload Product](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/Uploadproduct.abbajx.png)
  </Step>

  <Step title="Publish Your product landing page">
    Once your product is ready:

    * Click **Publish** to make the product live.
    * You can also **update the landing page slug**, move the product to **Unlisted** or **Draft** mode, and **access the landing page link** to preview it.\
      ![Publish Product](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/publishdownload.qfdkye.png)
  </Step>
</Steps>

***

## Product pricing and coupon codes

Pricing for downloadable products works the same way as it does for all other digital content on Fermion.

You can create a **[fixed pricing plan](/setup-pricing/fixed-pricing-plan)**, where buyers pay a one-time amount, or a **[partial payment plan](/setup-pricing/setup-emi)**, allowing payment in installments. For common queries regarding pricing plans, refer to [pricing FAQs](/setup-pricing/common-faqs).

Similarly, **coupon codes** also work the same for digital products as they do for courses. You can create discount codes, set expiration dates, and control usage limits. Learn more in the [coupon codes](/setup-pricing/add-coupon-codes) documentation.

***

## Enrolling users

Students can purchase **downloadable products** directly from the landing page.\
As an admin, you can also **manually enroll students** into a downloadable product.

Head over to the **Sales** section in your product builder to manually import users

[Learn how to manually enroll students](/digital-products/enroll-students)


# eBooks Inside Courses
Source: https://docs.fermion.app/digital-products/ebook-course

Learn how to connect your eBook to a course and allow enrolled students to access it from within the course.

You can enhance your **[course](/setting-up-course/prerequisites)** experience by linking an eBook to a course. This allows students enrolled in the course to access the eBook automatically without needing a separate purchase or enrollment.

<Steps>
  <Step title="Open the Course Builder">
    * Go to your **Instructor Dashboard → Courses → Open Course Builder**.
    * Select the course where you want to link your eBook.

    ![Open Course builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/course%20builder%20open.pdcqad.png)
  </Step>

  <Step title="Navigate to Syllabus Tab">
    * In the course builder, go to the **Syllabus** tab.
    * Identify the section where you want to add the eBook.
  </Step>

  <Step title="Add eBook to Section">
    * Click **Add in this section** for the chosen section.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/add%20in%20this%20section.zgbelu.png)
    * Select the **eBook** option in **Add course item** modal.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/add%20course%20item.becmtx.png)
  </Step>

  <Step title="Upload or Link eBook Directly">
    You can upload a **new eBook** or link a **preexisting one** directly from the **Select eBook to add** section.

    To link an existing eBook: Choose one from the list and click **Link with course item**.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/43EFQP78Mr.zlohgn.png)

    To upload a new eBook: Click **Quick Create eBook**, enter the eBook title, and upload your PDF file.\
    Once uploaded, click **Create Ebook** to make it available for linking. This eBook will be created in an unlisted state.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/V9mUphr1fh.hrghua.png)
  </Step>

  <Step title="Access eBook Inside the Course">
    Once linked:

    * Students enrolled in the course can open the eBook directly from the course dashboard.
    * Any updates to the eBook (like new versions) are reflected automatically for all students.
  </Step>
</Steps>

<Info>
  Linking eBooks to courses ensures a smooth experience for students and helps you bundle content efficiently. To enroll specific students outside of a course, refer to [Enroll Students](/digital-products/enroll-students).
</Info>


# Embed eBook
Source: https://docs.fermion.app/digital-products/embed-ebook

Learn how to embed an eBook externally

Embedding an [eBook](/digital-products/introduction) externally allows you to share your digital content on your own website or any other web platform while keeping it secure and protected. With Fermion, you can generate a secure embed token and integrate your eBook easily using an iframe. This guide walks you step by step through obtaining your eBook digital product ID, generating an authentication token, and embedding the eBook on your site so your audience can access it without leaving your platform.

Before you begin embedding your eBook externally, make sure you have the following ready:

<Columns>
  <Card title="eBook Digital Product ID" icon="book">
    This unique identifier lets Fermion know which eBook you want to embed. You can find this ID with the help of <strong>Step 1</strong> below.
  </Card>

  <Card title="Fermion API Key" icon="key">
    Used to authenticate your requests securely when generating the embed token. You can create or view your API key from the <strong>API Access</strong> section in your instructor dashboard sidebar.
  </Card>

  <Card title="Access to Your Website’s Codebase" icon="code">
    You’ll need to add a small code snippet (iframe) to your website, so make sure you have editing access or a developer who can implement it.
  </Card>
</Columns>

Once you have these three essentials, you can proceed to generate your secure embed token and integrate your eBook directly on your website with the help of steps below:

<Steps>
  <Step title="Obtain the ebook digital product ID">
    Each ebook on fermion has a unique identifier. For example `6779080e80ec97e953a17971`. First, go to `Manage features` tab on your instructor dashboard and enable `Digital products`

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/10-03-2025/15%20PM.ugncgw.png)

    After that, go to `eBooks` inside `Digital products` to create and upload an ebook if you haven't. Learn more about [Creating eBooks](/digital-products/landing-page)

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/10-03-2025/43%20PM.sapnvv.png)

    You can find the ebook digital product ID in the URL.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/10-03-2025/23%20PM.wulyuh.png)
  </Step>

  <Step title="Generate an Embed Token">
    You'll need to generate a JWT (JSON Web Token) to authenticate the embed. Here's how to create one using the `jsonwebtoken` package:

    ```javascript theme={null}
    import jwt from 'jsonwebtoken'

    const payloadObject = {
    	/* ... see the valid schema of the object below ... */
    }

    const jwtToken = jwt.sign(payloadObject, 'FERMION_API_KEY', {
    	expiresIn: '10h',
    })
    ```

    The `payloadObject` must conform to the following zod schema:

    ```js theme={null}
    z.object({
    	ebookDigitalProductId: z.string().min(1),
    	userEmail: z.string().email(),
    	userId: z.string().min(1),
    	userPhoneNumber: z.string().min(1).or(z.null()),
    })
    ```

    Important notes:

    * Replace `FERMION_API_KEY` with your actual API key and provide a unique user ID for each viewer.
    * Make sure to set a validity on JWT token (recommended validity is 10h-20h)

    <Info>
      Fermion uses the same zod schema as above internally to validate your JWT
      payload.
    </Info>
  </Step>

  <Step title="Embed the ebook">
    Add this iframe to your website where you want to embed the ebook:

    ```html theme={null}
    <iframe
    	width="1280"
    	height="720"
    	src="https://acme.fermion.app/embed/ebook?token=your_token_here"
    	title="Ebook"
    	frameborder="0"
    	allow="allow-same-origin; camera *;microphone *;display-capture *;encrypted-media;"
    	referrerpolicy="strict-origin-when-cross-origin"
    	allowfullscreen
    >
    </iframe>
    ```

    <Warning>
      Make sure you replace `acme.fermion.app` with your fermion school URL.
    </Warning>

    This should embed your ebook and display it on your website.
  </Step>
</Steps>


# Enroll Students
Source: https://docs.fermion.app/digital-products/enroll-students

Guide to manually or automatically enrolling users in your digital products on Fermion.

You can manage who gets access to your digital products directly from the Fermion dashboard. Whether users purchase through your landing page or you add them manually, Fermion makes enrollment simple and trackable.

<Info>
  You can also link your eBook to a course, allowing enrolled students to access the eBook automatically. Learn how to connect an eBook to a course in the [Link eBook to Course](/digital-products/ebook-course) documentation.
</Info>

***

## Steps to Enroll Users

You can enroll users into your digital products with the help of the same steps. Here, we are describing how to enroll students into an eBook. The flow works the same for all digital products including [courses](/setting-up-course/landing-page) and [bundles](/setting-up-course/bundle).

<Steps>
  <Step title="Navigate to the eBook Product Builder">
    1. Go to **Instructor Dashboard → Digital Products → eBooks → Open Product Builder** of your eBook.
    2. Click on the **Sales** (or **Students** tab of your respective product builder) tab in the sidebar.
    3. Click **Import new users** to start enrolling readers.
       ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/import%20new%20user.khvnnf.png)
  </Step>

  <Step title="Single User Enrollment">
    Use this form to enroll an individual user:

    * `Name:` Enter the name of the user
    * `Email:` Enter the email of the user
    * `Phone Number:` (Optional): Enter the phone number of the user
    * `Password:` (Optional): Create credentials for the user
    * `User creation timestamp:` (Optional):\*\* Select date when the user was created
    * `Welcome Email:` Select this checkbox if you want users with no account will receive an email with their new password and access details.

    After filling the form, click **Add Single User** to complete enrollment.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/Single%20user%20import.xvypvb.png)
  </Step>

  <Step title="CSV Import">
    Head over to the CSV import tab if you want to enroll students in a bulk format\
    Ensure your CSV includes all the following columns:

    * `Email` (required): Email of the user
    * `Name` (optional): Name of the user
    * `Password` (optional): Password credentials for the user
    * `Phone Number` (optional): Phone number of the user
    * `Created At` (optional): Timestamp when the user was created

    Upload your CSV file and your users will be enrolled to the eBook
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/csv%20import.mvlhit.png)
  </Step>

  <Step title="Import from Product">
    You can import users who are already enrolled in another product:

    * Select the product from which you want to import users.
    * Users from that specific product will be enrolled to your eBook

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/import%20from%20product.mfyjun.png)
  </Step>
</Steps>

***

## Exporting Student Details

To export your eBook’s reader list as a CSV:

<Steps>
  <Step title="Export Users">
    1. **Open Product Builder** of your eBook and head over to the **Sales** tab.
    2. Click on **Export all enrolled users as CSV** button.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/export%20details.dvtdfj.png)

    This will export all the details of the users enrolled in your eBook. You can use this export for reports, marketing campaigns, or syncing data with other tools.
  </Step>
</Steps>


# eBooks on Fermion
Source: https://docs.fermion.app/digital-products/introduction

Learn how to upload, manage, and sell eBooks on Fermion with watermarking, and secure delivery.

## What is an eBook?

An **eBook** (electronic book) is a digital version of a printed book that can be read on computers or tablets. Unlike physical books, eBooks can be easily distributed and accessed instantly.

On Fermion, eBooks are digital products that you can create, sell, and manage directly from your instructor dashboard. They can be linked to **[courses](/digital-products/ebook-course)**, **[embedded externally](/digital-products/embed-ebook)**, or sold as standalone resources to your audience. You can also add eBooks to [Bundles](/setting-up-course/bundle) at Fermion.

## eBooks on Fermion

eBooks on Fermion allow creators, educators, and publishers to share digital books securely and conveniently with their audience. Whether you are selling a professional guide, a course companion, or a digital textbook, Fermion gives you the flexibility to upload, protect, and distribute your eBooks with ease.
![eBook Example](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/10-03-2025/43%20PM.sapnvv.png)

Once you upload your eBook, Fermion automatically processes it to optimize reading performance and ensure smooth delivery to your users. Your eBook [Landing Page](/digital-products/landing-page) is the storefront for your digital content. It helps you showcase your eBook, highlight its value, and make it easy for learners to purchase or access it.

<Info>Before you start, make sure **Digital Products** are enabled under **Manage Features** in your instructor dashboard. This allows you to create and sell eBooks on Fermion. Learn how to enable features at Fermion [here](/manage-settings/manage-features)</Info>

***

## Key Features

Here is what you get with Fermion:

* **Watermarking:** Adds visible identifiers to your content to discourage piracy.
* **Download Prevention:** Restricts downloads to protect intellectual property, keeping your files secure. Learn more about these while setting up an [eBook Landing Page](/digital-products/landing-page#landing-page)
* **Optimized Reader Experience:** Fermion processes your eBook uploads for a consistent performance
* **[User Management:](/digital-products/enroll-students)** Track who has access to your eBook, and export enrolled user details as CSV for reporting or analysis.
* **[External Embedding](/digital-products/embed-ebook):** Easily embed your eBook on external websites or platforms using a secure iframe, allowing readers to access your content without leaving your site.

***

## Next Steps

Continue reading to explore how to set up each part of your eBook journey on Fermion:

<Columns>
  <Card title="Creating an eBook">
    Learn how to set up and publish your eBook on Fermion.
    [Learn more](/digital-products/landing-page)
  </Card>

  <Card title="Enrolling Users">
    Manage student enrollment and get your eBooks available to the user.
    [Learn more](/digital-products/enroll-students)
  </Card>

  <Card title="Export User Details">
    Export student details as CSV to track progress or reporting.
    [Learn more](/digital-products/enroll-students#exporting-student-details)
  </Card>
</Columns>


# Setup eBooks
Source: https://docs.fermion.app/digital-products/landing-page

Learn how to design, upload, and publish your first eBook on Fermion using the Product Builder.

Creating your first eBook on Fermion is simple and intuitive. This guide walks you through the entire process: from setting up a dedicated landing page to uploading your eBook file in the Product Builder. With Fermion,
you can showcase your digital content professionally, control access, and offer secure downloads to your audience.

<Info>Before you start, make sure **Digital Products** are enabled under **Manage Features** in your instructor dashboard. This allows you to create and sell eBooks on Fermion. Learn how to enable features at Fermion [here](/manage-settings/manage-features)</Info>

## Landing Page

Your eBook landing page is where potential readers discover and purchase your digital content. A clear, well-designed landing page helps you communicate your eBook’s value and drive conversions.

### Steps to create a Landing Page

<Steps>
  <Step title="Navigate to eBooks">
    1. Go to your **Instructor Dashboard → Digital Products → eBooks**.
    2. Select **Create new eBook** if you want to create a new eBook or update an existing one by clicking **Open Product Builder**.\
       ![Access Ebook](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/accessebook.wtapub.png)
  </Step>

  <Step title="Define Book Metadata">
    Navigate to the **Landing Page** tab in your eBooks sidebar.
    Add the essential details about your eBook:

    * **Book Title & Tagline:** Clearly describe your eBook and what readers can expect.
    * **Thumbnail / Cover Image:** Upload a high-resolution cover image to make your eBook stand out.
      ![Book Metadata](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/Book%20metadata.gyxccv.png)
  </Step>

  <Step title="Add a Book Description">
    Write a compelling and informative description of your eBook.\
    The description editor supports **Markdown**, so you can format text, create bullet points, add links, and emphasize content.
    ![Description](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/descriptionbook.civula.png)
  </Step>

  <Step title="Upload eBook and Configure Settings">
    Upload your eBook file (PDF format). Once uploaded, you can configure the following options:

    * **Enable book downloads?**\
      Allow buyers to download the eBook as a PDF after purchase.

    * **Enable centered watermark?**\
      Adds a light watermark in the center of every page for extra security.

    * **Enable header watermark?**\
      Adds a light watermark in the header of each page.
      ![Upload ebook](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/Upload%20ebook.uaeyht.png)

    * By clicking **Read book as user** button, you can preview how the eBook will look for your students
  </Step>

  <Step title="Publish Your eBook landing page">
    Once your eBook is ready:

    * Click **Publish** to make the eBook live.
    * You can also **update the landing page slug**, move the eBook to **Unlisted** or **Draft** mode, and **access the landing page link** to preview it.\
      ![Publish eBook](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/publish.ccugrk.png)

    <Info>
      You can also link your eBook to a course, allowing enrolled students to access the eBook automatically. Learn how to connect an eBook to a course in the [Link eBook to Course](/digital-products/ebook-course) documentation.
    </Info>
  </Step>
</Steps>

***

## eBook Pricing and Coupon Codes

Pricing for eBooks works the same way as it does for all other digital products on Fermion.

You can create a **[fixed pricing plan](/setup-pricing/fixed-pricing-plan)**, where buyers pay a one-time amount, or a **[partial payment pricing plan](/setup-pricing/setup-emi)**, allowing payment in installments. For common queries regarding pricing plans, you can refer [Pricing FAQs](/setup-pricing/common-faqs)

Similarly, **coupon codes** also work the same for eBooks as they do for courses and other digital products. You can create discount codes, set expiration dates, and control usage limits. To learn how to create and manage coupon codes for a product, refer to [Coupon Codes](/setup-pricing/add-coupon-codes) documentation.

## eBook Settings & Management

Manage your eBook’s settings and configurations to control access and maintain organization.

**Enrollment Settings:**\
Decide how students can enroll in your eBook. You can restrict enrollment to only admins, by checking the **Only allow you (admin) to enroll students in this ebook** box, meaning no one can buy or access the eBook independently, even if it’s published and public. For more information about enrolling users for an eBook, refer to [Enroll Users](/digital-products/enroll-students) documentation.
<Tip> If the eBook is part of a course, enrolled course users can still access it. Learn more about [Linking eBooks to course](/digital-products/ebook-course)</Tip>

**Management Actions:**\
Perform important actions to keep your eBook library organized:

* **Archive eBook:** Temporarily remove the eBook from public view without deleting it.
* **Delete eBook:** Permanently remove the eBook from your account. Please note that this action is **non reversible** in nature\
  ![Delete eBook](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/07-10-2025/deleteebook.izsrbq.png)


# Object Storage
Source: https://docs.fermion.app/digital-products/object-storage

Learn how to manage private and public files using Fermion object storage for your digital products and courses

Object storage on Fermion is a powerful file management system that allows you to upload, organize, and serve files for your [digital products](/digital-products/introduction), [courses](/setting-up-course/prerequisites), and other content. It provides a centralized location to store and manage all your files, from images and PDFs to videos and downloadable resources.

Fermion's object storage is designed with flexibility and security in mind, giving you complete control over how your files are accessed and distributed.

***

## Understanding file visibility

Object storage on Fermion has **two distinct types** of file storage based on visibility and access control:

### Private Files

**Private files** are secure files that cannot have publicly shareable URLs and are only for internal use within your Fermion platform. These files are ideal for:

* Student-only resources that require enrollment
* Internal course materials and [attachments](/setting-up-course/attachments)
* Protected [eBook](/digital-products/introduction) files
* Sensitive documents that should only be accessible to enrolled users
* Private [assignment](/setting-up-course/assignments) materials

### Public Files

**Public files** can be accessed by anyone on the internet with a direct link to the file. These files are suitable for:

* Landing page images and thumbnails
* Marketing materials and promotional graphics
* [Course landing page](/setting-up-course/landing-page) covers and banners
* [eBook landing page](/digital-products/landing-page) preview images
* Social media assets
* Public documentation and guides
* [Blog](/custom-landing-pages/blogs) post images
* Public [form](/forms/introduction) assets

<Warning>
  Be careful when uploading files to public storage. Once a file is made public, anyone with the URL can access it. Never upload sensitive information, student data, or proprietary content to public storage.
</Warning>

***

## How to Access Object Storage

<Steps>
  <Step title="Enable general object storage in manage features section">
    Make sure **General object storage feature** is enabled in your **manage feature** section before you access object storage. Learn more on how to [manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Navigate to Object Storage">
    1. Go to your **Instructor Dashboard → Settings**.
    2. Scroll down and click on **Object storage** in the settings menu.
       ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_xCwzXBVO7E.slagrl.png)
  </Step>

  <Step title="Choose Storage Type">
    Select between **Private Files** or **Public Files** tabs depending on the type of content you want to upload.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/Dz3AL3pgeo.sujtxk.png)
  </Step>

  <Step title="Upload Files">
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/1MEOahqkWO.jtbatp.png)

    * Drag and drop your files into the storage area
    * Wait for the upload to complete
    * Your files will appear in the storage browser with their URLs
    * You can also create new folder and provide a structure to your object storage.
  </Step>
</Steps>


# Access Form Submissions
Source: https://docs.fermion.app/forms/form-submissions

Learn how to view and manage submissions for your forms, including individual and table views, and exporting to CSV.

After creating and sharing a form, you can access all the responses submitted by users.\
Fermion allows you to view submissions in both **Individual View** and **Table View**, and export the data in **CSV format** for offline analysis.

## Access form submissions

You can access your form submissions directly inside your form editor with the help of the following steps:

<Steps>
  <Step title="Navigate to your form">
    Go to the **Forms** section in your dashboard and click on the form you want to access submissions for.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_ipsIcSjW9C.kdxlso.png)
  </Step>

  <Step title="Open submissions">
    On the top-left of the form page, click the **Submissions** tab. This will open the submissions panel where all responses are stored.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_9BePriswV5.rcwthw.png)
  </Step>

  <Step title="View table of submissions">
    * Switch to **Table View** to see all submissions in a spreadsheet-like format.
    * Here you can sort, filter, and quickly scan multiple responses at once.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_z2FCltYL8D.kdziyr.png)
  </Step>

  <Step title="View individual submission">
    * In the submissions panel, you can view all the responses respectively in a block view.
    * This is useful for reviewing single responses or following up with specific users.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_CbsvtWhS1m.ujtkgh.png)
  </Step>

  <Step title="Export submissions">
    * In the submissions panel, click the **Export CSV** button.
    * This will download all form responses in a spreadsheet-friendly format.
    * This file can be used for offline analysis, reporting, or importing into other tools.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_dNuod90shk.lggjid.png)
  </Step>
</Steps>

<Tip>
  Table view is best for quick analysis of multiple responses, while individual view is perfect for detailed inspection of a single submission. Always export CSV if you want to create backups or do further processing.
</Tip>


# Setup Forms
Source: https://docs.fermion.app/forms/introduction

Create multi-step forms and collect submissions

Fermion helps you build multi‑step forms to capture detailed information and feedback. You can also share a public link outside of your organization. Additinally, you can customize fields, require answers, add descriptions and cover images, then publish when ready.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_GRJPMe2Wou.rvdklp.png)
<Tip>You can also create onboarding forms attached to your school so that you can gather introductory data from new users. Learn more about [user onboarding forms](/forms/onboarding-form) </Tip>

## Getting Started

Setting up forms for your school is a simple process at Fermion. Perform the following steps to create elegant multi-step forms to collect data from your students:

<Steps>
  <Step title="Step 1: Enable Forms Feature">
    Make sure that the forms feature is enabled for your school.
    ![enable-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_E0AMceGCXS.mswisz.png)
  </Step>

  <Step title="Step 2: Navigate to Forms Page">
    Click on the 'Forms' page from your instructor dashboard's sidebar, then click on 'Create new form' button.
    ![navigate-to-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_RbfRTMHIDc.ohuohx.png)
  </Step>

  <Step title="Step 3: Form Editor Panes">
    Now, you will see the form editor page, consisting of 3 'Panes':

    * Blocks pane
    * Preview pane
    * Content pane

    ![forms-panes](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_RddA2GAD44.atnzef.png)

    The Blocks pane on the left lists steps, the center shows a live preview, and the Content pane on the right lets you configure the selected block.

    Note: By default, all new forms are pre-loaded with `Welcome` and `Thank you` blocks.
  </Step>

  <Step title="Step 4: Add a New Block">
    To add a new block, click on `Add blocks` button from the bottom of the blocks pane.
  </Step>

  <Step title="Step 5: Select Block Type">
    Once you click on `Add blocks` button you will see a popup with all the avaibale block types
    ![block-types-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_kje3lB6GrZ.exwmeu.png)
  </Step>

  <Step title="Step 6: Add the Block to Form">
    Select a block from here and click on `Add this block to form`. We offer the following blocks that are further customizable:

    * **Short text**: Capture brief responses such as names or titles.
    * **Long text**: Collect detailed answers or paragraphs.
    * **Phone number**: Gather users’ phone and contact number.
    * **Website**: Collect a URL from the user.
    * **Date**: Let users select a date.
    * **Address**: Collect full address details.
    * **Dropdown, Single and Multi select questions**: Allow users to choose one or multiple options.
    * **Number**: Allow the user to enter a number between a range specified by you.
    * **Contact information**: Capture full name, email, and mobile number.
    * **Star Rating**: Allows user to rate on a scale of 1-5 stars
    * **Opinion Scale** Lets users rate on a custom scale with labels.
    * **File upload**: Allow users to submit files or documents.

    For example, let's select `Short text` block.
    ![add-a-block-form](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_QMl2nRVcR0.utayex.png)
  </Step>

  <Step title="Step 7: Customize the Block">
    Once a block is added to the form, you can further configure it from the 'Content Pane' on the right side. This pane has multiple customization options like:

    * Edit your question
    * Edit your placeholder
    * Edit the text on the `Next` button
    * Add a description(with simple text formatting and the ability to include hyperlinks and YouTube videos)
    * Make a question mandatory
    * Add a cover image

    Additionally, depending on the block you select, the content panes' customization options will change. For example, the long text block has an option to customize character limit, the address block lets you customize the the street, city, stat, ZIP code and country fields' visibility and the rating block lets you customize the number of stars.

    ![customize-blocks-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-09-2025/seelen-ui_I2riZIssfo.wvnsjn.png)
  </Step>

  <Step title="Step 8: Arrange and Publish Form">
    Once you have added and customized all the blocks, you can further customize the 'flow' of the form by re-arranding the blocks. You can do this by clicking on the 'drag' handle on the blocks.
    ![drag-blocks-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_7QLpNABnGw.atawoh.png)

    Once you are done customizing your form, click on `Save` and then click on `Publish`. You can also preview the form by clicking on the `play` button.
    ![publish-forms](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_22KmzDWLfd.oyhtya.png)
  </Step>
</Steps>

And there you go, you have now created a form on Fermion. You can copy the form's link after publishing the form and share with your users!

## Next steps

<Columns>
  <Card title="Access Form Submissions">
    Learn how you can access form submissions from your users and also export them as CSV files
  </Card>
</Columns>


# User Onboarding Form
Source: https://docs.fermion.app/forms/onboarding-form

Create and assign an onboarding form for new users joining your school.

The **Onboarding Form** allows you to collect essential details from every new user who signs up for your school. When a new user creates an account, they’ll be prompted to fill out this form before accessing the platform. It’s a great way to gather important information like graduation level, interests, or consent details, ensuring a smoother onboarding experience.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_0A1OsdLFNb.bzwjri.png)

## Why use an onboarding form?

Onboarding forms help you collect essential information from new users automatically during sign-up. This information can include personal details, preferences, or any other data necessary to provide a tailored experience. By gathering responses upfront, you can personalize learning paths, verify eligibility, segment users into relevant groups, and ensure all necessary compliance or consent requirements are met.

Additionally, onboarding forms streamline administrative processes by reducing manual data entry and giving instructors a clear overview of each new user’s profile. The data collected can also help you make informed decisions and enhance the overall learning experience for students.

## How to attach an onboarding form to your school?

You can enable an onboarding form for a new user with the help of the following steps:

<Steps>
  <Step title="Enable Forms">
    Before creating your onboarding form, make sure the **Forms** feature is enabled for your school. Go to **Manage Features** in your admin panel and toggle on the **Forms** option.

    Learn more about how to [manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Create a new form">
    Once forms are enabled, you can create your onboarding form.\
    Navigate to the **Forms** section in your dashboard and click **Create Form**.

    Learn more about how to [create forms](/forms/introduction#getting-started)
  </Step>

  <Step title="Go to user onboarding form">
    After creating your form, go to **Users → User Onboarding Form** from your instructor dashboard sidebar.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_JnaUMgXop0.rtchrm.png)
  </Step>

  <Step title="Add onboarding form">
    Click on **Add Onboarding Form**, then select the form you created in the 2nd step.\
    Now click **confirm**, the form will automatically appear for every new user when they register.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_RpSWhSizUS.zgsfku.png)
  </Step>
</Steps>

*And voilà* , your onboarding form is now attached to your school and ready to collect user data!

## Viewing responses

All onboarding form submissions are automatically stored in the **Submissions** tab inside your form. You can export them as CSV or view them directly from your dashboard. Learn more about [accessing form submissions](/forms/form-submissions)
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_9BePriswV5.rcwthw.png)

## Next steps

<Columns>
  <Card title="eBooks" href="/digital-products/introduction">
    Create and publish ebooks to share structured learning material and in-depth guides with your students.
  </Card>

  <Card title="Blogs" href="/custom-landing-pages/blogs">
    Write and post blogs to share updates, announcements, and insights directly with your learners.
  </Card>
</Columns>


# Gamification Features
Source: https://docs.fermion.app/gamification/features

Explore all the gamification options on your Fermion platform including XP rewards, streaks, and leaderboards.

## Global settings

Global settings allow you to configure platform-wide gamification options that affect all users. This is where you control maximum XP, enable leaderboards, and configure streaks to ensure your platform provides a motivating experience for learners.

Head over to the **Gamification** section in your instructor dashboard sidebar to access these

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_nCipIsncWe.jffcmz.png)

### Maximum XP per user per day

Set a limit on the maximum XP a user can earn each day. By default, there is no limit, which means learners can accumulate as much XP as they earn by completing actions. This helps control excessive XP gain and maintain balanced progression.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_dRucwkk9Zn.gkbycv.png)

### Enable public leaderboard

Enable a public leaderboard to show top users in the platform sidebar. This fosters healthy competition and motivates learners to engage more with content to climb the leaderboard.

### Configure streaks

Streaks reward users for consecutive days of engagement. When enabled, a streak widget appears on their dashboard. You can also set the **Daily Streak XP Reward**, which defines how much XP users earn for maintaining their streak.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_k8AOnZZbJI.octekh.png)

***

## XP breakdown

XP breakdown allows you to configure rewards for specific user actions. This helps incentivize the behaviors you want, such as completing videos, articles, quizzes, or labs.

<AccordionGroup>
  <Accordion title="Daily attendance">
    Every new day a user visits the platform, they earn a set amount of XP. This encourages regular engagement and motivates users to consistently return to your platform.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_E0mQILhxuJ.vkyszl.png)
  </Accordion>

  <Accordion title="Recorded video completion">
    Users earn XP when they complete a video in a course. This incentivizes learners to watch content fully rather than skipping through, ensuring better understanding and engagement.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_23PuwoUH8B.ummkwc.png)
  </Accordion>

  <Accordion title="Coding labs">
    You can reward XP for partial completion (at least one challenge completed) and full completion (all challenges passed). Additionally, XP can be reduced if users download solutions, discouraging bypassing learning.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_zoylFg8Psz.myevbd.png)
  </Accordion>

  <Accordion title="Quizzes">
    Users can earn XP for attempting quizzes. This encourages students to actively participate in assessments, reinforcing their learning.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_TL7dY2ajgM.wvflxz.png)
  </Accordion>

  <Accordion title="Articles">
    Every time a user completes an article, they earn XP. This encourages reading and consuming written content, making learning more interactive.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_ibukeASM0X.igweue.png)
  </Accordion>

  <Accordion title="Livestreams">
    XP can be awarded for attending live sessions. This encourages participation in live interactions, increasing engagement and community involvement.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_ZSvdfX9dTq.eggdso.png)
  </Accordion>
</AccordionGroup>

After adding all the XP values for each milestone, click on **Save changes** button to update the gamification system of your school.

***

By configuring these features, you can create a dynamic, motivating, and engaging learning environment that rewards users for participation and progress. Make sure to experiment with XP values and streak rewards to optimize user engagement.


# Overview
Source: https://docs.fermion.app/gamification/introduction

Learn how to enable gamification on your Fermion platform to increase engagement, retention, and learner motivation.

Gamification adds game-like elements such as points, streaks, and leaderboards to your platform, making learning more engaging and motivating. By rewarding learners for completing actions, you can boost activity and retention while providing a fun and interactive learning experience. Instead of just passively consuming content, learners are encouraged to actively participate, attempt exercises, and complete courses to earn rewards.

## Why gamification is important for learners

Gamification leverages the natural human desire for achievement, recognition, and friendly competition. Points, badges, and streaks create a sense of accomplishment, motivating learners to stay consistent and complete tasks. Leaderboards foster healthy competition, while streaks and regular rewards help users form productive study habits and maintain engagement over time.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/YL4atfjEvw.amhxkx.png)

## Why gamification is important for instructors

For instructors and platform admins, gamification provides valuable insights into learner behavior. You can identify top performers, track which content items drive the most engagement, and adjust rewards to encourage specific actions. By making achievements and milestones visible, learners gain a clear sense of progress, and the overall user experience becomes more satisfying and enjoyable.

Head over to the **Leaderboard** section in your sidebar to look at the top performers!
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/0sXLlZKhhK.qtfzfv.png)

## How to enable gamification

<Steps>
  <Step title="Access manage features">
    Head over to the **Manage Features** section in your instructor dashboard sidebar. This section lists all the configurable features available on your platform.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_FieoyIicA5.lztydc.png)
  </Step>

  <Step title="Locate Gamification and enable it">
    Scroll down the list of features until you find **Gamification**.  Click on the **Enable** toggle to enable gamification across ur school. Click on **Save changes** to apply your changes.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_pMb656VjCb.fepcbl.png)
  </Step>
</Steps>

## Next steps

<Columns>
  <Card title="Explore Gamification Features" href="/gamification/features">
    Learn about XP rewards, streaks, leaderboards, and all the ways you can make learning engaging and motivating on your Fermion platform.
  </Card>
</Columns>


# Fermion vs other platforms
Source: https://docs.fermion.app/getting-started/fermion-vs-other-platforms

Learn how Fermion compares to other learning management platforms

Fermion has been created to serve businesses, academies, and creators who want to deliver exceptional online education. Our top priority is to provide you with a beautiful, seamless experience. While many traditional LMS platforms focus on general online education, Fermion offers specialized features for both technical and non-technical education, making it ideal for a wide range of learning scenarios.

## Why do organizations choose Fermion?

There are many other platforms like Graphy, Kajabi, Thinkific, Teachable, Rigi or TagMango, and in this quick read, we'll talk about why organizations choose Fermion to build their learning platforms:

## Built-in live classes

Unlike other platforms that require expensive third-party integrations with services like Zoom or Google Meet, Fermion provides built-in [live class](/live-classes/what-are-live-classes) capabilities at no additional cost. Our platform can handle up to 10,000 concurrent students without any extra charges, making it perfect for scaling your educational programs. This means:

* No surprise costs as your audience grows
* No need to manage multiple subscriptions
* Seamless integration with your course content
* High-quality video streaming with built-in DRM protection

## Interactive coding labs

Fermion revolutionizes technical education with its integrated coding labs and assessments. Our platform provides:

* One-click integration of coding labs into your courses
* Real-time code execution and feedback
* Interactive assessments that evaluate student progress
* Seamless experience for both instructors and students

## Complete brand control

Fermion gives you full control over your brand:

* Complete white-labeling capabilities
* Custom domain support
* Branded certificates and credentials
* Customizable course interface
* Your own branded mobile app
* Corporate identity integration

## Transparent, Usage-Based Pricing

We believe in complete transparency when it comes to pricing:

* No hidden costs or surprise charges
* Pay only for what you use (bandwidth, storage, compute)
* Clear pricing structure that scales with your needs
* No additional fees for features like live classes or assessments
* Enterprise-grade SLAs for business customers

## Built-in Video Infrastructure

Our platform includes enterprise-grade video capabilities:

* Integrated video streaming with DRM protection
* No need for external video hosting services
* Secure content delivery
* Adaptive streaming quality based on student's connection
* Corporate-grade security and compliance

Choosing the right platform is like choosing a partner—you need to think about the long-term value and how well it will support your goals. Many organizations choose Fermion because:

* Fermion supports their specific educational needs
* They get a smooth, integrated experience without managing multiple services
* Their audience gets a premium learning experience
* They maintain complete control over their brand and content
* They benefit from transparent, predictable pricing
* They can scale their programs without technical limitations

We've invested heavily in building the best technology and infrastructure to support your needs. With our multi-currency support worldwide, you don't need to worry about managing payments. Our flexible payout options allow you to request payouts on-demand.

To summarize – organizations choose Fermion because it offers specialized tools, interactive learning experiences, seamless live class capabilities, robust data transparency and security, flexible payment options, and support for collaborative teaching—all tailored to meet the unique demands of modern education.


# What's possible on Fermion
Source: https://docs.fermion.app/getting-started/what-can-you-do-on-fermion

Explore the features and capabilities of Fermion for businesses, academies, and creators

Fermion is built to serve businesses, academies, and creators who want to deliver exceptional online education. While we excel in technical education, our platform is designed to support a wide range of learning scenarios.

At its core, Fermion enables you to create interactive learning experiences through hands-on labs, assessments, and specialized tools for technical education. As an organization or creator, you'll have complete visibility into your students' learning journey.

Let's explore the key features in detail:

1. Cohort-based Courses
2. Live Class Infrastructure
3. Interactive Learning Environments
4. Video Streaming & DRM Protection
5. Data Security and Analytics
6. Global Payment Solutions
7. Collaborative Teaching

## Cohort-based Courses

Fermion provides flexible [course](/setting-up-course/prerequisites) creation options to meet your specific needs.

You can create various types of courses on Fermion:

* Recorded Courses
* Cohort-based Courses
* Hybrid Courses
* Workshops
* Custom Learning Programs

Cohorts on Fermion are structured through a weekly curriculum that can include live classes and pre-recorded lectures. This setup allows you to have complete control over how your courses are organized, enabling you to mix and match pre-recorded lectures and live classes to create an optimal learning experience.

Each cohort comes with a clear start date, end date, and enrolment deadline, ensuring a well-defined timeline for both you and your students.

## Live Class Infrastructure

Live teaching is a critical component of modern education, and Fermion provides enterprise-grade [live class](/live-classes/what-are-live-classes) capabilities built directly into the platform.

Unlike other solutions that require expensive third-party integrations with services like Google Meet, Webex, or Zoom, Fermion's built-in infrastructure eliminates additional costs and setup hassles. This means:

* No surprise costs as you scale
* Seamless integration with your course content
* High-quality video streaming
* Support for up to 10,000 concurrent students
* Built-in [DRM protection](/live-classes/drm-and-watermarking)

Fermion's in-house infrastructure ensures a smooth, uninterrupted teaching experience, allowing you to focus on delivering exceptional content.

## Interactive Learning Environments

Fermion stands out among traditional LMS platforms with its ability to integrate interactive learning environments, particularly for technical education.

Our platform supports:

* One-click integration of [coding labs](/live-classes/drm-and-watermarking)
* Real-time code execution and feedback
* Interactive assessments
* Hands-on projects
* Interview preparation kits

With over 5000+ coding labs and quiz questions available, you can easily add interactive and evaluative elements to your courses.

This comprehensive approach helps your courses stand out by offering practical learning experiences that are crucial for effective education.

## Video Streaming & DRM Protection

Fermion provides enterprise-grade [video streaming](/recorded-videos/introduction) infrastructure with comprehensive DRM protection to secure your valuable content:

* Built-in video hosting and streaming
* Multi-level DRM protection:
* Widevine DRM
* Fairplay DRM
* Custom watermarking
* Device binding
* IP-based restrictions
* Adaptive bitrate streaming
* Global CDN integration
* Offline viewing capabilities
* Analytics for video engagement
* Automatic quality adjustment based on network conditions

This robust infrastructure ensures your content remains secure while delivering a premium viewing experience to your students.

## Data Security and Analytics

Content security and data transparency are paramount in online education. Fermion prioritizes these aspects by providing:

* Robust DRM protection
* Widevine and Fairplay integration
* Detailed audience engagement analytics
* Course completion metrics
* Assessment performance reports
* 100% content control and visibility

These features ensure your content remains secure while providing valuable insights to continuously improve your educational programs.

## Global Payment Solutions

Fermion enables you to reach a global audience with comprehensive payment solutions:

* Support for international and domestic [payment gateways](/setup-pricing/payment-gateway)
* Integration with Stripe, PayPal, Razorpay, and more
* Coverage in over 150 countries
* In-house UPI payment gateway (0.5% transaction fee)
* Dynamic geo-pricing options
* Multi-currency support

Our payment infrastructure is specifically designed to handle global transactions efficiently and cost-effectively.

## Collaborative Teaching

Fermion supports collaborative teaching environments, making it ideal for organizations with multiple instructors or subject matter experts. You can:

* Add multiple instructors to courses
* Implement co-teaching models
* Share workload effectively
* Leverage specialized expertise
* Maintain consistent quality across sessions

This collaborative approach enables you to create comprehensive learning experiences that leverage the strengths of your entire teaching team.


# What is Fermion?
Source: https://docs.fermion.app/getting-started/what-is-fermion

Learn about Fermion and how it helps businesses, academies, and creators build their online learning platforms

Setting up your online learning platform can be a significant undertaking, with numerous considerations to evaluate.

<Card title="Which platform should I trust?" href="/" />

<Card title="Which platform will best serve my audience?" href="/" />

<Card title="Which platform will provide the optimal return on investment?" href="/" />

These are valid questions that any business, academy, or creator should consider when choosing a platform.

While numerous platforms exist in the market, this documentation introduces Fermion, a comprehensive platform designed to help you establish and scale your online learning business.

From this documentation, you'll learn about:

1. What is Fermion?
2. What can you do with Fermion?
3. How Fermion differs from other platforms
4. How to get started with your first course on Fermion

## What is Fermion?

Fermion is a comprehensive platform designed for businesses, training institutes, and content creators to establish and scale their online academies. Whether you're a corporate training department, an educational institution, or an independent creator, Fermion provides the tools you need to deliver exceptional online education.

When it comes to delivering premium online education, Fermion stands out as a premier solution. It offers the flexibility to be used as a fully managed learning management system (LMS) or as a modular platform where you can integrate specific services like live classes, assessments, and specialized tools for technical education.

The platform operates on a usage-based pricing model, similar to cloud providers, where you only pay for the resources you consume – whether it's bandwidth, storage, or compute power. This ensures that your costs scale proportionally with your growth, making it an ideal solution for both startups and established institutions.

For organizations that need more control, Fermion provides a comprehensive API that allows you to integrate its services headlessly into your existing infrastructure. This means you can leverage Fermion's powerful features while maintaining your own custom user interface and workflows.

We'll explore Fermion's capabilities in greater detail throughout this documentation.

## Why create a platform like Fermion?

Through extensive research and conversations with businesses, academies, and creators, we identified common challenges across various learning management systems.

### Common challenges

Organizations reported issues ranging from inadequate support to suboptimal user interfaces, problematic live streaming capabilities, and lack of scalability.

Fermion was developed to address these specific pain points while providing the flexibility and scalability that modern educational platforms require. Whether you're just starting out or running a large-scale academy, Fermion grows with you, adapting to your needs without requiring platform migrations or major infrastructure changes.

World-class educators and organizations should focus on delivering exceptional education rather than troubleshooting technical issues. This philosophy guides our approach when welcoming new partners to our platform.

Our vision is straightforward – to provide businesses, academies, and creators with a robust platform for establishing their online learning platforms, allowing them to concentrate solely on delivering outstanding educational content.

With Fermion, we're committed to creating an exceptional experience for both content providers and their students.

## What can you do with Fermion?

The platform offers comprehensive functionality, with its core features enabling the creation of interactive learning experiences through live classes, assessments, and specialized tools for technical education.

As an organization or creator, you'll have complete visibility into your students' learning journey. You can choose to use Fermion as a complete solution or integrate specific components like:

* Live class infrastructure
* Assessment and evaluation tools
* Student progress tracking
* Interactive learning environments
* Custom integrations through our API
* White-labeling and branding options

In the upcoming articles, we'll explore:

* Fermion's core capabilities
* Fermion's unique advantages over other platforms
* Getting started with your first course
* Features and tools to enhance your students' learning experience


# Embedding Vimeo Videos Inside Courses
Source: https://docs.fermion.app/guides/vimeo-embed

Learn how to embed Vimeo videos inside courses using iframe embeds, and understand the trade-offs compared to Fermion’s built-in video library.

Embedding a Vimeo video inside your course is a straightforward way to include external video content without uploading it to Fermion directly. Using an iframe embed, you can display any Vimeo-hosted video seamlessly within your course player. However, while this approach is simple, it also comes with certain limitations that you should be aware of before implementing it.

## How does this integration work?

When you embed a Vimeo video using an iframe, the player will load directly from Vimeo’s servers. This means that while students will be able to view the video without issues, Fermion will not be able to track analytics at the student level. Features like tracking video completion, enforcing watch-time constraints (such as requiring the learner to finish watching the entire video), or providing granular progress analytics will not be available.

<Tip>
  We recommend using the **[Fermion Video Library](/recorded-videos/video-library)** for an optimized learning experience. Videos uploaded directly to Fermion come with built-in analytics, progress tracking, and viewing constraints that help maintain course integrity and engagement.
</Tip>

To embed a Vimeo video into a course using an iframe, follow these steps carefully. Make sure you have the Vimeo embed URL ready (for example, `https://vimeo.com/123456789`).

<Steps>
  <Step title="Open the Course Builder">
    * Go to your **Instructor Dashboard → Courses → Open Course Builder**.
    * Select the [course](/setting-up-course/prerequisites) where you want to link your Vimeo video.

    ![Open Course builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/course%20builder%20open.pdcqad.png)
  </Step>

  <Step title="Head over to the syllabus">
    Navigate to the **Syllabus** tab of the course where you want to embed the Vimeo video. Choose the section in which you’d like the video to appear.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_UtYdAyvMZf.vpylpm.png)
  </Step>

  <Step title="Add a new item to the section">
    Within the section, click on **Add in this section** to open the course item modal.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_3afVyL6QRM.ulsiok.png)

    From the available item types, select **Iframe Embed** to create a new embedded video resource.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_QGjaHXn1MF.qrilat.png)
  </Step>

  <Step title="Enter iframe details">
    Provide a suitable **Iframe Title** for your embedded video to help learners identify it easily. Then, paste your **Vimeo Embed URL** into the iframe URL field. Double-check that the URL follows Vimeo’s embed format and not the standard watch URL.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_CmOi2DT63m.quqyze.png)

    <Warning>
      Make sure that the Vimeo video you are embedding allows **external embedding**. If the video’s privacy settings restrict where it can be embedded, the player may display an error. To fix this, update the video’s privacy settings on Vimeo by going to **Settings → Privacy → Video → Where can this video be embedded?** and choosing  **Anywhere**. Learn more about [embedding vimeo videos]()
    </Warning>
  </Step>

  <Step title="Publish your changes">
    Once you’ve entered all the details, click **Publish** to save your changes.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_KmA71xD4VV.yenmmw.png)
  </Step>
</Steps>

After completing all these steps, the Vimeo video will now be available inside your course, and learners will be able to access it directly within the course player interface.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_Q3Tl2zfqrt.hgbbky.png)

While this embedding method works for quick integrations or when external hosting is preferred, for complete learning analytics, progress tracking, and a seamless course experience, the Fermion [Video Library](/recorded-videos/video-library) remains the recommended choice. To learn more about embedding Vimeo videos externally, please refer to [Vimeo documentation](https://vimeo.com/blog/post/how-to-embed-videos)


# AI Summary
Source: https://docs.fermion.app/live-classes/ai-summary

Generate AI-powered summaries of your live sessions based on transcripts, providing students with key topics and concepts from the entire session.

After your live session is recorded and AI captions are generated, Fermion can automatically create an AI-powered summary of the entire session. This summary provides students with a comprehensive overview of key topics, concepts, and takeaways from the live event, making it easier for them to review and understand the content.

The AI summary is generated based on the transcript of the live session and appears below the video player for easy access. This feature helps students quickly grasp the main points covered during the session without having to watch the entire recording.

**Note:** For AI summary to work, AI captions must be enabled first. The summary is generated automatically once the transcript is available.

## Enabling AI Summary

To enable AI summary for a specific live event, follow these steps:

<Steps>
  <Step title="Go to Courses">
    Navigate to the **Courses** section.
  </Step>

  <Step title="Open the Course Builder">
    Open the **Course Builder** for a cohort-based course.<br />

    <img alt="steps 1 and 2" />
  </Step>

  <Step title="Navigate to Live events">
    Go to the **Live events** tab for your course.
  </Step>

  <Step title="Edit the relevant live event">
    Click **Edit** on the relevant live event.<br />

    <img alt="steps 3 and 4" />
  </Step>

  <Step title="Enable required options in Advanced Settings">
    In **Advanced Settings**:

    * Enable the `AI Transcripts` option to generate AI Transcripts (required for AI Summary)
    * Enable the `Recorded playback` option to make sure users can watch the live stream recording<br />

    <img alt="AI options" />
  </Step>
</Steps>

AI captions can also be enabled globally for your school at: Settings > School settings > Livestreaming settings.

There is a brief processing time for the AI summary to be generated, which depends on factors like the duration of the call and the length of the transcript. Once ready, the summary will be automatically displayed to students viewing the recorded session.

Once the recording and captions are processed for the live session, users can see a summary like shown below:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_xL3ODTwkMa.ztwwwe.png)


# Clone Live Classes
Source: https://docs.fermion.app/live-classes/cloning-class

Learn how to clone a live class from one cohort-based course to another in just a few clicks.

Cloning a [live class](/live-classes/what-are-live-classes) allows you to quickly reuse an existing session setup, including the title, timing, and hosts, in another [cohort-based course](/setting-up-course/prerequisites#what-is-a-cohort-based-course%3F) without having to create everything from scratch. It’s a simple way to save time and maintain consistency when running multiple cohorts or repeating sessions for new batches.

<Tip>
  You can clone a live event inside another cohort-based course you have on the platform. This
  allows you to go live at once in two or more courses.
</Tip>

## Steps to clone a live class

You can clone a live class from one cohort based course to another with the help of the following steps:

<Steps>
  <Step title="Go to Courses">From your dashboard, navigate to the **Courses** section.</Step>

  <Step title="Open the cohort-based course">
    Select the **Cohort-based Course** that contains the live class you want to clone. ![Course
    Builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/open%20course%20builder.wfarfd.png)
  </Step>

  <Step title="Go to the Syllabus section">
    Navigate to the **Syllabus** section of the selected course.
  </Step>

  <Step title="Open options menu">
    Click the **three dots (⋮)** next to the live class you want to duplicate.
  </Step>

  <Step title="Select 'Clone in another CBC'">
    Choose **Clone in another CBC** from the dropdown menu. ![Duplicate in
    CBC](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/syllabus.gcnvyk.png)
  </Step>

  <Step title="Select target course">
    From the list, select the cohort-based course you want to clone the class to.
  </Step>

  <Step title="Add the class">
    Click **Add Class in this course** to confirm. ![Add class to
    course](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/add%20class.mqrkwm.png)
  </Step>
</Steps>

Once cloned, the live class will appear in the target course’s syllabus with all its original details intact, including the title, timing, and hosts. Cloning saves time and ensures consistency across multiple cohorts, so you can focus on delivering great sessions rather than recreating content.

<Info>
  Use cloning when running recurring sessions, orientation classes, or live events that need to be
  repeated across multiple courses. It helps maintain a consistent experience for all learners.
</Info>


# Frequently Asked Questions
Source: https://docs.fermion.app/live-classes/common-faqs

Common questions regarding live classes on Fermion

This document addresses frequently asked questions regarding live class functionality on the Fermion platform.

### Do I need to purchase any external license to conduct live classes?

No external licenses are required to conduct live classes on the Fermion platform. All necessary functionality is included within your Fermion subscription.

### Do I need to link my Zoom or Meet account to Fermion?

No account integration with external video conferencing platforms is required. Fermion provides an integrated solution for conducting live classes.

### How will students be notified of upcoming live classes?

When utilizing Fermion's built-in livestreaming functionality as your primary Learning Management System (LMS), automated notifications are sent to all enrolled students:

* 24 hours prior to the scheduled class
* 30 minutes before the class commencement

For API-based livestreaming implementations, instructors are responsible for managing student notifications manually.

To maximize student participation, we recommend utilizing both the automated notification system and community group announcements for important class updates.


# DRM and Video Watermarking
Source: https://docs.fermion.app/live-classes/drm-and-watermarking

Protect your live streams with DRM encryption and dynamic video watermarking to prevent unauthorized access and content piracy.

Fermion provides robust content protection mechanisms to safeguard your valuable educational content from unauthorized distribution and piracy. Our platform integrates industry-standard Digital Rights Management (DRM) technology alongside customizable video watermarking features, ensuring your intellectual property remains secure throughout the streaming and playback process.

## Digital Rights Management (DRM)

Fermion's built-in DRM support encrypts your live stream content, making it extremely difficult for unauthorized users to download, record, or redistribute your videos. This enterprise-grade protection works seamlessly across all supported devices and browsers, providing peace of mind while you focus on delivering quality education.

### Key DRM Features

* **Automatic encryption:** All live streams(with DRM enabled) are automatically encrypted using industry-standard protocols
* **Device-level protection:** Content is protected at the hardware level on supported devices
* **Browser compatibility:** Works across Chrome, Firefox, Safari, and Edge browsers.

### Enable DRM for your live sessions

1. Go to the **Live events** page on any of your cohort based course.
2. Click on **Edit** next to a live stream or **+Add Session**
   ![steps1and2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_zbT8lOIE8f.sgwbuo.png)
3. From the `Advanced Settings` section, make sure that **DRM protect playback** option is toggled.
4. Click on **Save Changes**
   ![turn on DRM](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_UlpbU4rjPu.dtdivl.jpg)

## Video Watermarking

In addition to DRM, Fermion offers dynamic video watermarking that overlays unique identifiers on each viewer's stream. This powerful feature acts as a deterrent against content piracy and helps you identify the source of any leaked content.

### How Video Watermarking Works

When enabled, each student viewing your live stream receives a unique watermark containing their user information. This watermark is dynamically generated and cannot be easily removed, making it possible to trace any unauthorized sharing back to the original viewer.

### Watermarking Options

* **User ID watermarking:** Display the student's unique identifier on the video
* **Email watermarking:** Show the registered email address of the viewer
* **Name:** Add users' name as an identifier to the watermark
* **Phone number:** Shows the viewers mobile number.
* **Font size control:** Choose where the watermark appears on the screen
* **Opacity settings:** Adjust watermark visibility to balance security with viewing experience

## Enabling Video Watermarking

To enable video watermarking settings for your school:

1. Go to **Settings** → **School settings** → **Security**
   ![navigate-to-security](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_GS0mZUYwH6.tzjfzv.jpg)
2. Toggle "Enable video watermarking".
3. Set **Font Size** (px) and **Opacity** (%) to your preference.
4. Choose which identifiers to display:
   > * Name
   > * Email Address
   > * Phone Number
   > * User ID (unique ID generated for every user on the platform)
5. Review the live preview, then select "Save security settings"

Preview with only Name and User ID selected:
![Watermark preview](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/video-watermark.mqethn.png)


# Embedding live session externally
Source: https://docs.fermion.app/live-classes/embed-live-session

Learn about embedding live sessions externally and customizing the look and feel for them

Fermion allows you to embed live calls externally using a simple integration. This is useful if you wish to add realtime calls on your own website and do not wish to use Fermion managed LMS.

There are a few steps you need to do in order to embed a session externally.

## Step 1 - Creating a new session

The first step to embedding a session externally is to create it programmatically on Fermion.

1. You must call this API endpoint: [https://docs.fermion.app/api-reference/live/create-live-session](https://docs.fermion.app/api-reference/live/create-live-session)
2. Once you call this endpoint, you will get `liveEventSessionId` in response.
3. You must store this `liveEventSessionId` in your database somewhere.
4. `liveEventSessionId` allows you to control the session completely using APIs, as we will see now below.

<Tip>
  You can create sessions anytime, on the fly using API. In the API above you would see that it
  accepts a start time and duration as well, but those are only used as hints, and not enforced.
</Tip>

## Step 2 - Embedding the session on your website

Once you have obtained `liveEventSessionId`, embedding the session on your website involves two steps.

### Generating a signed JWT

A signed JWT is required for any user with any permission (host or student) to be able to participate. This token must be generated by your backend.

Here is an example of how to generate this in Node.js:

```js theme={null}
import jwt from 'jsonwebtoken'

const payloadObject = {
	// --- Required fields ---
	liveEventSessionId: 'your-live-session-id',
	userId: 'your-internal-user-id',

	// --- Optional fields ---
	name: 'Jane Doe', // Optional default name to use for the user. If provided, this value will override the existing name.
	profilePicUrl: 'https://example.com/images/jane-doe-avatar.png', // Optional default profile photo URL to use for the user. If provided, this value will override the existing profile photo.

	// --- Optional object with defaults ---
	// All playback options are set to false by default
	playbackOptions: {
		shouldDisallowRecordedPlaybackIfNotLive: false, // If true, once the livestream ends, the same JWT that is used to embed the stream would not be able to playback the recorded version of the video
		shouldPreferOnlyHighDefinitionPlayback: true, // If true, system would enforce only 1080p and 720p modes of playback. Note: Passing this as true might result in buffering on user side if their internet is not fast (as this disables low quality playback versions)
		shouldHideSeekControls: false, // If true, it will hide the seek controls (seekbar and jump forward/backward buttons) from the UI
		customBrandingData: {
			// Optional: If you pass this branding information, it would be used to show logo / brand name instead of your primary school brand name
			name: 'Custom Brand Name',
			logoUrl: 'https://example.com/images/custom-logo.png' // Optional logo URL
		}
	}
}

// Generate the JWT token using the complete payload
const jwtToken = jwt.sign(payloadObject, FERMION_API_KEY, {
	expiresIn: '10m'
})
```

### JWT Payload Fields

**Required fields:**

1. `liveEventSessionId` - The same ID that you got when you created session over API.
2. `userId` - A unique ID for a user that you're creating the playback session for. Note that it should be a stable ID. It can be anything like a database identifier or even an email address of the user. However two sessions must not be sharing same stable ID, otherwise they will be considered as a single user.

**Optional fields:**

3. `name` - Optional default name to use for the user. If provided, this value will override the existing name.
4. `profilePicUrl` - Optional default profile photo URL to use for the user. If provided, this value will override the existing profile photo.

**Optional `playbackOptions` object:**

The `playbackOptions` object is optional and has the following default values if not provided:

* `shouldDisallowRecordedPlaybackIfNotLive` (default: `false`) - If you pass this as `true`, once the livestream ends, the same JWT that is used to embed the stream would not be able to playback the recorded version of the video.
* `shouldPreferOnlyHighDefinitionPlayback` (default: `false`) - If you pass this as `true`, system would enforce only 1080p and 720p modes of playback. Note: Passing this as `true` might result in buffering on user side if their internet is not fast (as this disables low quality playback versions).
* `shouldHideSeekControls` (default: `false`) - If you pass this as `true`, it will hide the seek controls (seekbar and jump forward/backward buttons) from the UI.
* `customBrandingData` (optional) - If you pass this branding information, it would be used to show logo / brand name instead of your primary school brand name. This object contains:
  * `name` (required) - The custom brand name to display.
  * `logoUrl` (optional) - URL to the custom logo image.

Once the token is ready, you need to embed the session.

### Embedding the live call session (Fermion SDK)

In your frontend JavaScript app, install the fermion SDK. Run one of the following depending on your package manager:

```bash theme={null}
npm install @fermion-app/sdk

# or

pnpm install @fermion-app/sdk

# or

yarn install @fermion-app/sdk
```

Now, in order to get the iframe embed code, you can use fermion SDK as follows:

```js theme={null}
import { FermionLivestreamVideo } from '@fermion-app/sdk/livestream-video'

// Create a livestream instance
const livestream = new FermionLivestreamVideo({
	// this must be replaced by the same live event session ID you got from API call
	liveEventSessionId: 'your-live-session-id',

	// this must be replaced by your real domain you have on fermion
	websiteHostname: 'your-domain.fermion.app'
})

// Embed the live session (requires JWT token)
const embed = livestream.getPrivateEmbedPlaybackIframeCode({
	// pass down the JWT token you created in last step
	jwtToken: 'your-jwt-token'
})

// embed this code somewhere in your HTML
// this is a string which looks like `<iframe src=....`
const iframeHtmlCode = embed.iframeHtml
```

### Embedding the live call session (Manually)

Once you have created JWT from backend, you can also embed the iframe session manually. Here is what the iframe code would be:

```html theme={null}
<iframe
	width="1280"
	height="720"
	src="https://your-website.com/embed/live-session?liveEventSessionId=:your-session-id:&token=:your-jwt-token:"
	title="Video"
	frameborder="0"
	allow="allow-same-origin; camera *;microphone *;display-capture *;encrypted-media;"
	referrerpolicy="strict-origin-when-cross-origin"
	allowfullscreen
>
</iframe>
```

Please make sure to replace the following placeholders with appropirate values:

1. `your-website.com`: Domain you have with fermion
2. `:your-session-id:`: Live event session ID you got from API
3. `:your-jwt-token:`: Signing token you created in last step

## Step 3 - Assigning a primary host

When you open the webpage in browser, you'll only see a black screen and no video playing or livestream controls.

This is expected because every session, by default, **is embedded as a student-view (view-only)**. You need to add a host to the call who will be responsible for starting the session, switching students within stage/audience, conducting polls, whiteboards, etc.

You must do that using this endpoint: [https://docs.fermion.app/api-reference/live/modify-live-session-user-state](https://docs.fermion.app/api-reference/live/modify-live-session-user-state) with the type of `update-permissions`

The API above expects you to pass:

* User ID (same ID you created at the time of generating the JWT)
* Updated permission level

Here's a payload to pass in the API call, that will make a given user, a host in the meeting:

```json theme={null}
{
	"liveEventSessionId": ":your-session-id-here:",
	"userId": ":your-user-id-here:",
	"action": {
		"type": "update-permissions",
		"newPermissions": {
			"shouldAllowAdministrativeActions": true
		}
	}
}
```

Note that you can programmatically control more parts in the user journey (including starting the session/ending the session/adding or removing people from the call), but once you have upgraded someone to be a host, if you refresh the same embed page where you have placed your iframe earlier, you will see that the host will see controls to start the meeting.

Once the meeting is started, the host will be able to turn on camera/mic/whiteboard/screenshare, etc. and also manage students.

## window\.postMessage events

When you embed the live session on your domain, the iframe will emit events in real-time through the `window.postMessage` API. You can read more about [`window.postMessage` API here](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage).

These events are emitted from both live WebRTC sessions and recorded video playback. This allows you to track user engagement, respond to session lifecycle changes, and build interactive experiences around your embedded live sessions.

Note that you must not fully rely on events emitted by `window.postMessage` because of security reasons. Please do a server-side validation with our real API endpoint to be sure of the final result. You can use messages from `window.postMessage` to optimistically display results, however, since it is a client-side API, it is possible to hijack the event data by the untrusted user.

You can listen to every postMessage like this:

```js theme={null}
window.addEventListener('message', event => {
	const payload = event.data

	if (payload == null || typeof payload !== 'object' || !('type' in payload)) {
		// not from fermion
		return
	}

	if (payload.type === 'webrtc:livestream-ended') {
		// handle live session ended
	}
})
```

We also recommend processing `event.data` with zod if you can. Our schemas are strictly typed and are zod-parseable.

Here are the events we emit through `window.postMessage` API:

### webrtc:livestream-ended

This event fires when a live WebRTC session ends (typically when the host ends the session for everyone). Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'webrtc:livestream-ended'
}
```

Use this event to trigger navigation, show a post-session survey, or redirect users after the live session concludes.

### webrtc:left-stage

This event fires when someone leaves the stage during a live WebRTC session. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'webrtc:left-stage'
}
```

Use this event to track stage participation, update UI to reflect who's currently on stage, or trigger notifications when participants leave the stage.

### video:play

This event fires when a user plays the recorded video playback. Note that this event only fires during recorded playback, not during live sessions. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'video:play'
	durationAtInSeconds: number
}
```

The `durationAtInSeconds` field indicates the playback position when the user pressed play. Use this event to track playback engagement and viewing patterns.

### video:pause

This event fires when a user pauses the recorded video playback. Note that this event only fires during recorded playback, not during live sessions. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'video:pause'
	durationAtInSeconds: number
}
```

The `durationAtInSeconds` field indicates the playback position when the user pressed pause. Use this event to track viewing patterns and engagement metrics.

### video:ended

This event fires when the recorded video playback reaches the end. Note that this event only fires during recorded playback, not during live sessions. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'video:ended'
}
```

Use this event to trigger completion actions, show the next lesson, or mark the session as completed in your system.

### video:livestream-ended

This event fires when a live stream transitions to VOD (video-on-demand / recorded) mode. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'video:livestream-ended'
}
```

Use this event to notify users that the live session has ended but the recording is available for playback. This is different from `webrtc:livestream-ended` as it relates to the HLS stream transitioning from live to recorded mode.

### video:time-updated

This event fires periodically during recorded video playback (every few seconds). Note that this event only fires during recorded playback, not during live sessions. Here's a TypeScript type for this event:

```ts theme={null}
type Event = {
	type: 'video:time-updated'
	currentTimeInSeconds: number
}
```

The `currentTimeInSeconds` field indicates the current playback position. Use this event to track detailed viewing progress, create bookmarks, or show custom overlays. Note that this event fires frequently, so consider throttling or debouncing on the receiving end if you're performing expensive operations.

### Complete TypeScript Type

Here's a complete TypeScript discriminated union type for all live event postMessage events:

```ts theme={null}
type LiveEventPostMessageEvent =
	| { type: 'video:play'; durationAtInSeconds: number }
	| { type: 'video:pause'; durationAtInSeconds: number }
	| { type: 'video:ended' }
	| { type: 'video:livestream-ended' }
	| { type: 'webrtc:livestream-ended' }
	| { type: 'webrtc:left-stage' }
	| { type: 'video:time-updated'; currentTimeInSeconds: number }
```

### Important Notes

* **Video events** (`video:*`) only fire during recorded video playback. If a user is watching the live session in real-time, these events will not be emitted.
* **WebRTC events** (`webrtc:*`) only fire during live sessions when users are connected via WebRTC.
* The `playbackOptions` object in the JWT token (mentioned in Step 2) controls playback behavior, which affects which events users might see.
* Some sessions may have both live and recorded phases. During the live phase, you'll receive WebRTC events. After the session ends and transitions to recorded playback, you'll receive video events.

## Using the Fermion SDK for event handling

If you're using the Fermion SDK (installed via `@fermion-app/sdk`), you don't need to manually set up `window.addEventListener` for postMessage events. The SDK provides a convenient `setupEventListenersOnVideo()` method that handles all the complexity for you.

### Benefits of using the SDK

* **Type-safe callbacks**: TypeScript definitions ensure you're handling events correctly
* **Automatic validation**: The SDK validates incoming events automatically
* **Cleaner API**: More intuitive methods instead of manual postMessage parsing
* **Built-in cleanup**: Easy disposal of event listeners to prevent memory leaks

### Example usage

```ts theme={null}
import { FermionLivestreamVideo } from '@fermion-app/sdk/livestream-video'

const livestream = new FermionLivestreamVideo({
	liveEventSessionId: 'your-live-session-id',
	websiteHostname: 'your-domain.fermion.app'
})

// Set up event listeners
const events = livestream.setupEventListenersOnVideo()

// Listen for video play event
events.onVideoPlay(data => {
	console.log('Video started playing at', data.durationAtInSeconds, 'seconds')
})

// Listen for video pause event
events.onVideoPaused(data => {
	console.log('Video paused at', data.durationAtInSeconds, 'seconds')
})

// Listen for video ended event
events.onVideoEnded(() => {
	console.log('Video playback finished')
})

// Listen for time updates (fires periodically during playback)
events.onTimeUpdated(data => {
	console.log('Current playback position:', data.currentTimeInSeconds, 'seconds')
})

// Listen for livestream ended event
events.onLivestreamEnded(data => {
	if (data.type === 'webrtc') {
		console.log('Live WebRTC session ended')
	} else {
		console.log('Live HLS stream ended (now in VOD mode)')
	}
})

// When you're done (e.g., component unmount), clean up the listeners
events.dispose()
```

The SDK automatically handles event validation, origin checking, and provides a more developer-friendly API compared to manually listening to postMessage events.


# Event Calendar
Source: https://docs.fermion.app/live-classes/event-calendar

Learn how to use Fermion's Event Calendar to plan, schedule, and manage live events and classes effortlessly, either individually or in bulk using CSV uploads.

## Introduction

The **Event Calendar** in Fermion brings all your [live sessions](/live-classes/what-are-live-classes) and events together in one simple, easy-to-manage view. Instead of jumping between different tools or tracking schedules manually, you can plan, edit, and manage all your sessions directly from one place.

![Calendar introduction](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Calendarintro.isusio.png)

It’s especially useful when managing multiple cohorts or working with different instructors, event calendar enables you to view all upcoming sessions, check for overlaps, and make quick adjustments when needed. This helps ensure a smoother experience for everyone involved, from planning to teaching to attending. With the Event Calendar, managing your live learning schedule becomes much more straightforward and reliable.

## How to access the Event Calendar

Accessing the **Event Calendar** in Fermion takes just a few simple steps.

1. In the instructor dashboard sidebar, navigate to the **Live** section, this is where all the live classes tools are located.
2. From the dropdown options, select **Event Calendar**.

![How to access event calendar](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/chrome_v6CwiECIuO.pwztmp.png)

You’ll now see a full calendar view displaying all scheduled sessions.

## Schedule a live session directly in Event calendar

Scheduling a live session directly from the **Event Calendar** is simple and helps you plan individual classes, workshops, or office hours without any extra setup. The process is easy to follow - you can open the calendar, pick a date, and fill in the details right away. This makes it ideal for one-off sessions or smaller events that don’t require bulk scheduling.

1. Open your **Fermion Dashboard** and navigate to the **Event Calendar** from the sidebar.
2. On the calendar view, click on the **date** where you want to schedule your session. A **Create a new session** form will appear.
3. Select the **course** the session belongs to.

![Session creation](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Schedule%20an%20event.wdanqo.png)

4. Enter a clear **Title** for the session.

5. Set the **Start Time** and **Duration** in minutes, and add the **email addresses** of any co-hosts or instructors.

   <Tip>
     Admins can always start sessions, but you can also add additional hosts and instructors by adding
     their email addresses in the same form!
   </Tip>

6. Review your details and click **Create Session** to confirm.

<Info>
  You can also schedule live classes inside a cohort based course, Learn more about that in [Setup
  Live Class](/live-classes/setup-live-class)
</Info>

## How to bulk schedule Live Classes via CSV

When you’re planning multiple live sessions at once: like an entire term’s timetable or a series of workshops, the **Bulk schedule via CSV** feature can save a lot of time. Instead of creating each session manually, you can prepare all the details in a single CSV file and upload them together.

1. Open the **Event Calendar** from your Fermion Dashboard.

2. Click the **Bulk schedule via CSV** button at the top of the page.
   ![Bulk schedule steps](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/bulsteps.uxikka.png)

3. Select your prepared CSV file from your device and upload it. Make sure it follows the specifications outlined in the [CSV Format Details](/live-classes/event-calendar#csv-format-details) section

   <Note>
     You can also download a **sample CSV** directly from the **Bulk Schedule** interface to
     check the correct format before uploading your own file.
   </Note>

   ![Bulk schedule form](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Bulk%20Schedule.cmcilj.png)

4. Click to **Schedule Event** button to schedule multiple live events at once

### CSV format details

Each row in your CSV file represents one session to be scheduled. Make sure to include all the following columns in your CSV file:

* `productSlug` (required): Slug to identify the cohort-based course.
* `itemTitle` (required): Title of the session.
* `sectionName` (required): Name of the section or module where the session belongs.
* `liveSessionStartAt` (optional): Date and time of the session (e.g. *January 31 2025 02:15:00 PM*).
* `liveSessionHostsEmails` (optional): Comma-separated list of host email addresses.
* `durationInSeconds` (optional): Duration of the session in seconds (e.g. *3600* for 1 hour or *1800* for 30 minutes).

## Hosting Public Events

In addition to managing private sessions and classes, Fermion also lets you host **[Public Events](/live-classes/public-event)**: sessions that anyone can join via a shared link, without enrolling in a course.\
This is ideal for **webinars**, **open workshops**, or **community sessions** where you want to reach a wider audience.

You can create a **Public Event** directly from your **Live → Public Events** section in the dashboard. Learn more about the process in [Public Events](/live-classes/public-event)


# Stage
Source: https://docs.fermion.app/live-classes/invite-to-stage

Learn how to use Fermion's Stage to host interactive live sessions, allowing participants to join the stage, screenshare, turn on their microphone and camera, and engage directly with the class.

Fermion's **Stage** feature is designed to make live sessions more interactive and engaging. It allows instructors to bring selected participants to the forefront, enabling them to share their screens, turn on their microphones and cameras, and actively participate in discussions.

### Managing Participants on Stage

Livestreaming on Fermion allows you to invite multiple students and instructors to the call. Currently, you can have up to 150 participants on 'Stage', allowing them to screenshare, turn on their microphone and camera to interact with the participants.

For smaller sessions, instructors can also automatically add everyone to the stage
for better communication between a small group of people.

On the right pane, you can see a list of participants who are present in your livestream. Enable **Automatically add everyone on stage?** checkbox to ensure all participants are on the stage and can interact with others.

![Add everyone to stage](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_b0OT9b6Nzn.kpfkdw.png)

Additionally, this option can be globally toggled from: **Settings** → **School Settings** → **Livestreaming settings**.
![toggle-autoadd-to-stage](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_MzVBFUJ7g1.mqcock.png)

You can also manually pick and choose which users are to be added onto the stage.

To do this, open the **Participants** or **Audience** panel on the right side. Users who are not currently on stage will be listed under "audience". Simply click the **Add on stage** button next to the user's name to invite them to the stage.

![Add on stage UI](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-12-2025/Arc_VtcQL1DJ00.fbyzqw.png)

You may select individual users or use the **Select all** checkbox to bring multiple users to the stage at once. When added, they will be able to turn on their microphone, camera, and screen share to interact with the class.

### Managing permissions on stage

When users are brought on **stage** during a live session, instructors and hosts can **manage user permissions** directly from the participant list. The following controls are available for each user, as visible in the stage participant panel:

![Stage permissions UI](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-12-2025/Arc_S9ZJP1iUVQ.pngsln.png)

From left to right, you can:

* **Disable camera** for a user: Click the camera icon to turn off the user's camera (they will no longer be visible until they turn it back on).

* **Mute microphone** for a user: Click the mic icon to mute their audio in the session.

* **Promote to host**: Click the green shield icon to give a user host privileges. Hosts can manage users on stage, access the [whiteboard](/live-classes/whiteboard), screenshare, and control audio/video for others. Hosts can also end the session for everyone

* **Remove from hosts**: Click the yellow shield icon next to a host's name to revoke their host privileges. This will revert them to regular participant status, and they will lose the ability to manage other users or session controls.
  ![yellow shield icon](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-12-2025/Arc_datL4U4IeW.bmnwgn.png)

* **Remove from stage**: Click the last icon (person with minus) to remove the user from the stage. The user returns to the audience and can no longer interact via mic or camera until re-invited.

> **Tip:** You can assign multiple hosts in a session. This is helpful for co-instructors, teaching assistants, or guest speakers who need full session control.

Managing these permissions allows you to maintain a smooth and secure class environment, keeping discussions focused and giving you control over who can present or participate at any time.

### Sharing System Audio

Live sessions often go beyond just visuals - you might want to play a tutorial video or share a demo
with your live class. Fermion now allows instructors to **share system audio** while
presenting on Stage, ensuring that any sound played from your device is
heard clearly by all participants in real time.

Here is how you can share system audio:

1. Join the **Stage** during a live session.

2. Click on **Share Screen**.

3. In the sharing dialog, enable the **“Also share tab audio”** option.

   ![Share System Audio](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/05-10-2025/Share%20system%20audio.arnfvv.png)

4. Select the tab you want to share and confirm your selection by clicking **Share**.

5. Begin your livestream. Participants will now hear both your system audio and your voice in real time.


# Live Chat
Source: https://docs.fermion.app/live-classes/live-chat

Enable real-time communications with the help of Live Chat to keep students engaged and informed

Fermion's live chat feature enables real-time communication between instructors and students during [live sessions](/live-classes/what-are-live-classes). The chat interface supports rich interactions including direct messaging, user mentions, file attachments, and interactive polls, creating an engaging learning environment where students can actively participate and collaborate.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_N6UDGIOu5N.dddtbl.png)

## High-volume chat

The chat system is designed to handle high-volume conversations with thousands of participants simultaneously, ensuring smooth communication even in large-scale live sessions. Messages are delivered instantly, allowing for dynamic Q\&A sessions, quick clarifications, and spontaneous discussions that enhance the learning experience.

## Instructor and student engagement

Instructors can leverage the chat to gauge student understanding, collect instant feedback, and maintain engagement throughout the session. Students can tag specific participants using @ mentions to direct questions or responses, share relevant files and resources, and participate in polls to provide collective input on topics being discussed.

## How to access chat during a live session

Click on the chat button in the bottom right pane inside a livestream to access live chat.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/QdBPqVl1fC.grootr.png)

The chat interface remains accessible throughout the entire live session and can be used alongside other features like screen sharing and stage participation. All chat messages are preserved and can be reviewed after the session ends, providing a valuable reference for both instructors and students.

![Live Chat Interface](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/chrome_lQOt9w4iJE.xlddop.png)

## Live Chat Popout

The Live Chat Popout feature allows participants to detach the chat interface into a separate browser window, providing greater flexibility during live sessions. This enables learners to follow the discussion while navigating other parts of the session or reviewing shared materials.
If a participant wishes to return to the main interface, they can easily restore the chat by clicking **Restore Chat** inside the livestream window, instantly bringing the chat back to its original position.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/GTVS9ek3uB.myrkjc.png)

## Disable Chat for Everyone

Instructors can now temporarily disable the chat for all participants with a single click. This is especially useful during important explanations, presentations, or assessments where focus is essential. When disabled, all participants will see a message indicating that chat is currently unavailable until re-enabled by the host.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_5QVvmxmw9t.xnqccf.png)

After you disable the chat with this button,  nobody will be able to message inside the chat.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_2aQ0TZs0ls.csipjd.png)

## Private Chat Mode

The Private Chat Mode provides a structured and secure way to manage direct communication during sessions.
In this mode:

<AccordionGroup>
  <Accordion title="Hosts" icon="user-cog">
    Hosts can read all messages and reply to any participant.\
    This gives them complete visibility and control over conversations, ensuring productive and moderated communication throughout the live session.
  </Accordion>

  <Accordion title="Participants" icon="users">
    Participants can only view and reply to messages from the host and their own messages, ensuring privacy and minimizing distractions.\
    Messages from other participants remain hidden, creating a focused and one-on-one communication experience.
  </Accordion>
</AccordionGroup>

Messages from other participants remain hidden, maintaining a clear and moderated communication channel. This mode is ideal for conducting Q\&A sessions, handling sensitive discussions, or maintaining discipline during large-scale live events.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_J4djbPRtVO.ennmfd.png)

## Key capabilities

Fermion's live chat is designed to make real-time communication seamless and engaging for both instructors and students. From instant messaging to collaborative interactions, the chat ensures that learning remains interactive, organized, and productive throughout the session.

<Columns>
  <Card title="Real-time messaging">
    Send and receive messages instantly with zero lag, even with thousands of active participants in
    the session.
  </Card>

  <Card title="User mentions">
    Tag specific students or instructors using @ mentions to direct questions, responses, or draw
    attention to important points.
  </Card>

  <Card title="File attachments">
    Share documents, images, code snippets, and other resources directly in the chat for immediate
    access by all participants.
  </Card>

  <Card title="Interactive polls">
    Create quick polls to gather student opinions, test understanding, or make collective decisions
    during the live session.
  </Card>

  <Card title="Message history">
    All chat messages are preserved and accessible after the session, allowing students to review
    discussions and shared resources.
  </Card>

  <Card title="Moderation controls">
    Instructors have the ability to manage chat behavior, ensuring a productive and respectful
    learning environment.
  </Card>
</Columns>


# Live Class Analytics
Source: https://docs.fermion.app/live-classes/livestream-analytics

Understand and access detailed analytics for your live sessions, including attendance, engagement, and performance insights.

[Live classes](/live-classes/what-are-live-classes) on Fermion let you host interactive sessions with your learners in real time directly inside your [cohort based courses](/setting-up-course/prerequisites#what-is-a-cohort-based-course%3F). They’re a powerful way to connect, teach, and engage your audience.

After every session, Fermion automatically tracks detailed analytics so you can understand how your livestream performed. Various recorded statistics include attendance, engagement, and viewer behavior. These insights help you improve future sessions and better understand your learners’ interaction patterns.

***

## Accessing livestream analytics

You can view livestream statistics in two ways.

<Steps>
  <Step title="Open course builder">
    Head over to the Courses tab in your instructor dashboard sidebar and open the course builder
    for the respective live stream session's parent course.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_Ts28KeQGMJ.gnqyyj.png)
  </Step>

  <Step title="Access via syllabus">
    1. Open the desired course and go to the **Syllabus** section. 2. Find the session that was
       livestreamed, click the **three dots (⋮)** next to it, and select **Edit**. This will open the
       live session manager.
       ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/reach%20syllabus.pykfxm.png)
    2. Click **VIew Stats** to view detailed analytics for that specific session. ![Livestream
       Syllabus
       Stats](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/statsinsidesyllabus.ammkpi.png)
  </Step>

  <Step title="Access via Course Builder">
    1. From the **Live Events** tab in your course builder, select the date of the livestream you
       wish to analyze. 2. Click **View stream stats** button next to the desired live stream to open
       the analytics dashboard. ![Course Builder Livestream
       Stats](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/liveventsstats.xgjjss.png)
  </Step>
</Steps>

***

## Livestream stats overview

Once you open the analytics page, you’ll see a comprehensive overview of the livestream’s performance metrics:

* `Total attendees`: The total number of learners who joined the session.
* `Peak concurrent`: The highest number of viewers watching simultaneously.
* `Avg. watch time`: The average time each participant spent watching your session.
* `Session duration`: The total duration of the livestream.
* `Audience engagement over time`: A live graph showing how engagement (viewers, chats, on-stage users) changed throughout the session.
* `Users brought on stage`: The number of participants who were invited on stage during the session.
* `Total viewing hours`: The cumulative total of all viewers’ watch time.
* `Chat messages`: The number of messages sent in the chat during the livestream.

![Livestream Stats](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_6WVsGnfPeF.wzjvcj.png)

Below these stats, you’ll find a list of **all participants**, showing their **time on stage** and **watch time** individually, giving you detailed insights into how long each learner stayed and interacted.

![Livestream Stats Participants](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/srrJ8PaO6a.hzagnm.png)

***

## Livestream ratings

At the top-right corner of the analytics page, you can access **Livestream Ratings**: a quick summary of how your viewers rated their session experience.\
Click the **"See livestream ratings"** button to see detailed feedback and understand audience satisfaction.

***

## Exporting data

To keep a record or analyze results further, you can **download all livestream analytics** in a `.csv` file.\
Simply click the **Download Results as CSV** button located at the top-right of the analytics dashboard.


# Livestream Settings
Source: https://docs.fermion.app/live-classes/livestream-settings

Learn how to configure audio, video, and general settings during a live session on Fermion.

Once you are inside a livestream, you can configure your session experience using the **Settings** menu. Click the **Settings** button on the livestream interface to open three configuration tabs: **Audio**, **Video**, and **General**.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-10-2025/chrome_WZlj7V4kHT.padeye.png)

***

## Audio Settings

Use the **Audio** tab to manage your microphone and speaker sources.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-10-2025/chrome_Mp1m2zl5ib.stwhym.png)

You can:

* Select your preferred **microphone input** for clear sound.
* Choose a **speaker output** for sound output of the livestream.
* Adjust input/output devices at any time during the livestream.

***

## Video Settings

Use the **Video** tab to manage your camera configuration.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-10-2025/chrome_KrmYh1gAKb.xeybiz.png)

You can:

* Select a camera source connected to your device.
* Switch between available cameras while live.

***

## General Settings

The **General** tab lets you manage participant permissions and engagement settings.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-12-2025/Arc_YnFxYfLxxW.eoodte.png)

Available options are:

* **Can users request to join stage?**
  When this option is enabled, participants can request to join the [stage](/live-classes/invite-to-stage) during a livestream. This allows them to share their audio, video, or screen with the host and other attendees.

* **Automatically add everyone on stage**
  Automatically brings all participants to the stage when enabled.

* **Enable chat for everyone**
  Allows all participants to send messages in the [live chat](/live-classes/live-chat).

* **Enable private chat**
  The Enable private chat toggle activates Private Chat Mode, allowing participants to send direct messages during a livestream while maintaining host supervision. When enabled, hosts can view and respond to all private messages, whereas participants can only see and reply to messages from the host or their own. Learn more about [Private chat mode](/live-classes/live-chat#private-chat-mode)

* **Hide tiles with no media in recording**
  When this option is enabled, any participant who has both their camera and microphone turned off will not appear in the session recording when a screen or specific content is pinned. This helps focus the recording on active speakers and shared content, eliminating empty or inactive video tiles from what is captured. It's especially useful for creating high-quality recordings where you want viewers to see only the main presentation or those actively participating.

  Note: Users who turn on their camera or microphone will automatically be shown again in the recording, as long as content is pinned

* **Hide tiles with no media**
  Participants with camera and mic off will be hidden from your view when a screen/content is pinned.


# 1:1 Calls
Source: https://docs.fermion.app/live-classes/one-one-calls

Set up and host one-on-one video calls with learners directly from your instructor dashboard.

1:1 Calls on Fermion allow instructors to connect privately with learners for personalized sessions such as mentorship, doubt-clearing, or performance reviews. These calls use the same reliable streaming infrastructure as [live classes](/live-classes/what-are-live-classes) but are designed for focused, one-on-one interaction. You can use them for office hours, feedback sessions, or quick catch-ups with students.

## How to start a 1:1 call

You can start 1:1 calls with your leaners with the help of the following steps:

<Steps>
  <Step title="Enable the 1:1 calls feature">
    Go to the **Manage Features** section and enable **1:1 Calls** for your school. Learn how to
    enable features [here](/manage-settings/manage-features).
  </Step>

  <Step title="Open the instructor dashboard">
    From your instructor dashboard sidebar, select **Live Classes**, then click on **1:1 Calls**.
    Once there, click **Create new 1:1 call** to begin setting up your session.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/11.rikzna.png)
  </Step>

  <Step title="Join and start the call">
    After creating the session, click **Join call** to enter the 1:1 room. You can now start the
    session and share the invite link with your student directly. To invite a learner, simply **copy
    the call link from your browser’s URL bar** and send it to them.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/chrome_iWkkqS1pQM.vycygw.png)
  </Step>
</Steps>

Here you have it! Your **1:1 Call** is now live and can be shared with learners using the generated invite link. Instructors can begin the session immediately and manage it just like a regular live class.

***

## Explore 1:1 call features

1:1 Calls come equipped with all the essential tools you’re familiar with from live classes, including [**screen sharing**](/live-classes/invite-to-stage#managing-participants-on-stage) and [**live chat**](/live-classes/live-chat). This ensures that your private sessions are as interactive and feature-rich as any cohort-based live event, but in a more personal, focused environment.

![1:1 Call Example](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/6Gw5Jd8JXs.buoiqj.png)

<Tip>
  1:1 Calls are ideal for private mentorship or support sessions where you want to provide
  dedicated time to a single learner.
</Tip>

## Next steps

<Columns>
  <Card title="Embed a Live Class">
    Learn how to **embed live sessions** on external websites so learners can join directly without
    switching tabs. [Go to guide](/live-classes/embed-live-session)
  </Card>

  <Card title="View Live Class Analytics">
    Understand how your live classes perform with **engagement analytics**, attendance data, and
    insights into learner participation. [See analytics docs](/live-classes/livestream-analytics)
  </Card>
</Columns>


# Pin a Tile
Source: https://docs.fermion.app/live-classes/pin-a-tile

Learn how to pin a participant’s video tile during a live session to keep all students focused on the same content.

During [live sessions](/live-classes/what-are-live-classes), instructors can pin a specific participant's tile to ensure all students view the same content simultaneously. This feature is particularly useful when you want to highlight a specific speaker, demonstration, or presentation to the entire class.

## How tiles work

When you pin a tile, it becomes the primary focus for all participants in the live session, overriding their individual view preferences. This ensures everyone stays synchronized and focused on the same content, making it ideal for scenarios like guest lectures, student presentations, or when demonstrating specific concepts.

## Pinning a tile

To pin a tile during a live session, simply hover over the participant's video tile and click the pin icon. The pinned view will immediately apply to all students in the session. You can unpin at any time to return control of the view to individual students.

<Tip>
  Only **meeting hosts** have the ability to pin and unpin a participant's tile. This ensures that
  the session remains organized and all students are focused on the intended content without
  conflicting views from other participants.
</Tip>

![Pin tile for everyone](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_EjLoHMTZsT.yhqihy.png)

## Stage management

This feature works seamlessly with Fermion's [stage](/live-classes/invite-to-stage) management capabilities, allowing you to create a more structured and engaging learning experience for your students.

## Next steps

<Columns>
  <Card title="Live chat" href="/live-classes/live-chat">
    Learn how to enable real-time communication during live sessions, engage students with
    interactive messaging, file sharing, and polls.
  </Card>

  <Card title="AI transcripts & auto recording" href="/live-classes/recording-and-captions">
    Discover how to automatically generate transcripts and record live sessions for easy reference,
    accessibility, and improved learner engagement.
  </Card>
</Columns>


# Public Events
Source: https://docs.fermion.app/live-classes/public-event

Host live sessions that are open to everyone using Fermion’s Public Events feature.

## Overview

[Live Events](/live-classes/what-are-live-classes) on Fermion can be added inside your courses, or hosted as **public sessions** accessible to anyone through a shareable invite link.
This gives you complete flexibility: teach within a structured course or reach a wider audience with open webinars, bootcamps, and workshops.

***

## Creating a Public Event

Creating a public event allows you to host sessions that anyone can join using a shareable link, making it perfect for webinars, workshops, or open community classes. Follow the steps below to set up your event from start to finish.

<Steps>
  <Step title="Enable Live Events">
    Make sure the **Live Events** feature is enabled under **[Manage Features](/manage-settings/manage-features)** in your instructor dashboard.
  </Step>

  <Step title="Access public events">
    Navigate to **Live → Public Events** from your instructor dashboard sidebar. Here you can click
    **Create New Event** or open an existing one in the **Product Builder** to edit.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/start%20live%20event.gtrays.png)
  </Step>

  <Step title="Give your public event a name">
    Give your public event a clear and engaging title.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/live%20event%20name.wgvylg.png)
  </Step>

  <Step title="Add public event metadata">
    Head over to the **Landing Page** section in your public event sidebar and start customizing your event’s basic details.
    Add the following information:

    * **Title**
    * **Short Description**
    * **Thumbnail**

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/live%20event%20metadata.gennsx.png)
  </Step>

  <Step title="Write public event description">
    Use the **Public Event Description** editor to add detailed content about your session. This
    section supports **rich text**, so you can include headings, formatted text, hyperlinks, and
    lists to make your event page more engaging.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/live%20event%20description.jojohe.png)
  </Step>

  <Step title="Publish your event">
    Once everything looks perfect, hit **Publish**.
    Your public event will now be live, and you can **copy the event link** to share the landing page of the live event. On top of that, you can also set a custom slug for your public event.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/publish%20live%20event%20landing%20page.rwialq.png)
  </Step>
</Steps>

***

## Standalone Invites

Stand-alone invites allow you to share access to your Public Events without requiring students to register for a full course or cohort. They are ideal for special webinars, bootcamps, workshops, guest sessions, or promotional live events.

With stand-alone invites, you can **control access**, **track participation**, and easily **revoke or reactivate** invites as needed. This provides flexibility for both organizers and attendees while keeping your events secure and manageable.

***

## Create a stand-alone invite for public events

Use stand-alone invites to give participants access to a public live event through a unique link with the help of the following steps:

<Steps>
  <Step title="Enable Live Sessions feature">
    Before creating a public event and invites, make sure the **Live Sessions** feature is enabled in your account. Learn how to [**Manage Features**](/onboarding/account-setup#step-2%3A-manage-features)
  </Step>

  <Step title="Create a New Public Event">
    1. Navigate to **Live → Public Event** in your dashboard.
    2. Click on **Create New Event** to start a public live session.  You can also create invites for previously created live events by clicking **Open product builder** . Learn more about creating [Public Events](/live-classes/public-event)

    ![create event](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/create%20new%20live.jnevif.png)
  </Step>

  <Step title="Access the Invites section">
    1. Click on **Create public invites** in the landing page builder
       ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_Amiu2PS4qX.ohxjxf.png)
    2. Click on **Create new invite** to create a new invite ID and a public link.
       ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_UEgge36P7F.ppmvcp.png)
  </Step>

  <Step title="Share and manage the invite">
    Once your invite is created, you'll see it listed below the create new invite button, showing key options for managing access.

    * Click **Get link** to copy the unique invite URL and share it with participants.
    * The **Status** column displays the current state (e.g., **Active**).
      * To temporarily block access, click the status menu and select **Revoke Invite**.
      * To allow access again, select **Reactivate Invite** in the same menu.
    * Use the checkboxes to choose whether to collect participants' email addresses or phone numbers when they join using your invite.

    ![Invite URL table with controls for sharing, status, and data collection](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_YyWkJhsOq7.irsziu.png)

    And that's it! You can now share the invite link with your audience and manage access and data collection preferences directly from this table.
  </Step>
</Steps>

Stand-alone invites make it simple to share access to your public [live events]() with a controlled audience. You can create, share, revoke, and reactivate invites easily, ensuring a smooth experience for both organizers and participants.

***

## Session management

Manage and customize your public event sessions from the **Manage sessions** tab. Here you can configure streaming preferences, event timing, playback permissions, and participant notifications to ensure a seamless viewing experience.
Head over to the **Manage sessions** tab in your product builder to access settings of the public event.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_IAkfyyiPxP.hgszfy.png)

### Go live

You can use the **Manage sessions** tab to go live with your public event. Click on the **Go live** button in Stream controls to start the live session

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_2QeHVdqZ01.gdmvxp.png)

### **Start time**

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_u4Vw6kOVya.medbiy.png)

Displays the scheduled start time for your live session.
Example: `24 Oct, 2025 – 5:47 PM (Your local timezone)`

### **Estimated event duration**

Set an approximate duration for your session (e.g., one hour). Your session can continue beyond the estimated time without any interruption.

### **Allow recorded playback**

If enabled, participants can rewatch the session recording after it ends. If disabled, playback will be unavailable once the live event concludes. Learn more about [auto-recording](/live-classes/recording-and-captions).

### **Enable reminder emails**

Send automatic reminders to registered participants at key intervals before the event begins:

* 24 hours before the event
* 6 hours before the event
* 30 minutes before the event

This ensures participants don’t miss your live session.

### **DRM protected playback**

When enabled, playback is secured with DRM protection: preventing screen recording or screenshots (similar to Netflix or Amazon Prime Video). Learn more about [DRM protection](/live-classes/drm-and-watermarking).

<Tip>
  Please note that DRM usage is billed separately. Head over to [Fermion Pricing](https://fermion.app/pricing)
  for more information regarding DRM playbacks
</Tip>

### External hosts

You can invite additional hosts to help manage your live event.
Hosts have administrative privileges : including starting or ending the stream, inviting speakers to stage, and moderating participants.

To **add an external host**, perform the following steps:

1. Enter the host’s email address in the **Add a new host** field.
2. Click **Add** to give the user with this email address host privileges.
   ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_kcjJQvq6Ds.hpyoqm.png)

## Pricing & Coupon Codes

Pricing for public events works **exactly like pricing for other product types** (such as [Courses](/setting-up-course/prerequisites) or [eBooks](/digital-products/introduction)).
You can set fixed prices, discounted prices, and manage regional pricing if applicable.

[Learn how to set up pricing](/setup-pricing/fixed-pricing-plan)

You can also apply coupon codes to public events, similar to other products.
This allows you to offer limited-time deals or special access promotions.

[Learn how to create coupon codes](/setup-pricing/add-coupon-codes)

<Check>
  Coupons and pricing logic remain consistent across all product types for a unified experience.
</Check>

***

## Enrolling students

Students can purchase access to **public events** from the landing page.
As an admin, you can also **manually enroll students** into a public event, for example, for corporate access or complimentary offers.

Head over to the **Students** section in your product builder to manually import users

[Learn how to manually enroll students](/digital-products/enroll-students)

***

## Management settings

Manage how your public live event behaves after setup, including certificates to administrative actions. Head over to the **Settings** tab in your public event sidebar to access these settings.

### Completion certificate

Control whether attendees receive a **certificate of completion** after the live event.
By default, certificates are **disabled**. Toggle **“Issue certificate of completion”** to enable, then click **Save Changes** to apply.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/09-10-2025/live%20event%20settings.rsnrcw.png)

### Management actions

<Accordion title="Archive live event">
  Temporarily hide the event without deleting it. Archived events can be restored later if you
  wish to make them available again.
</Accordion>

<Accordion title="Delete live event permanently">
  Completely remove the event and all its data from your account. Use this only when you’re sure
  the event is no longer needed.

  <Warning>
    This action **cannot be undone**! Once deleted, the event and all related data are
    permanently removed.
  </Warning>
</Accordion>


# Transcripts / Auto-Recordings
Source: https://docs.fermion.app/live-classes/recording-and-captions

Automatically record live sessions with AI-generated captions and provide downloadable videos for accessible, on-demand learning.

Upon completion of your live session, Fermion automatically converts it into a video recording and makes it available to your students. Instructors can opt in to generate AI-powered captions, which are automatically created in the same language used during the live stream.

This feature enhances accessibility for students and makes your content more inclusive. The captions are automatically synchronized with the video timeline and can be toggled on or off by viewers. There is a brief processing time for the recording to be available and for captions to be generated, which depends on factors like the duration of the call, total number of participants, and the number of users on stage.

## Accessing Captions via Webhooks

For advanced integrations, you can programmatically access the generated captions through Fermion's webhook system. This allows you to:

* Receive real-time notifications when captions are generated
* Integrate caption data into your own systems or workflows
* Build custom caption viewers or editors
* Archive captions in your preferred storage solution

When a live session's captions are ready, Fermion will send a webhook event to your configured endpoint with the caption data in standard formats (SRT, VTT). This enables seamless automation and integration with your existing tools.

For detailed information on setting up webhooks and handling caption events, refer to our [Webhooks documentation](/webhooks/event-payloads).

Additionally, You can make this recording downloadable so your students can access it offline.

To enable recording and captions, follow these steps:

1. Go to Courses
2. Open the Course Builder for a cohort based course
   ![steps1and2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_nY8HS0bvMJ.ocwenm.jpg)
3. Navigate to Live events
4. Click Edit on the relevant live event
   ![steps3and4](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_KN3tY6F4zB.lwpmkv.png)
5. Go to Advanced Settings and - Enable the `Allow students to download MP4` option to let students download the recording - Enable the `AI Transcripts` option to generate AI Transcripts
   ![download-live-session](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/Arc_ehjP6aeIbp.cwridc.png)

This feature can also be enabled globally for your school at: Settings > School settings > Livestreaming settings.
![global-captions-toggle](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_fRUHVxarHo.tfyieg.png)

Fermion Pro members have 5 hours of transcription included in their plan. Any additional transcriptions are charged at 0.3\$/hour.
Please refer to [Fermion Pricing](https://fermion.app/pricing).


# Schedule a Live Class in Fermion
Source: https://docs.fermion.app/live-classes/setup-live-class

Learn how to create, configure, and schedule live classes in Fermion.

Hosting a live class on Fermion lets you deliver lessons in real time,
interact directly with your learners, and create an engaging, collaborative experience inside your course.
Setting up a live session involves configuring essential details like your session title, description and timing of the session. You’ll also learn how to customize session behavior, enable reminders, add additional hosts, and configure recording or transcript options so your learners get the best possible experience.

Once your setup is complete, you’ll be ready to go live and manage your class using Fermion’s built-in tools for screen sharing, [whiteboarding](/live-classes/whiteboard), and [stage management](/live-classes/invite-to-stage).

## Some pre-requisites

Before getting started, make sure of the following things:

1. Have a good internet connection before you stream so that the stream doesn't buffer or lag, these issues are usually caused by poor network connections.

2. Make sure that your browser and graphic drivers are up-to date, to avoid any issues that arise with outdated versions.

3. Keep a good webcam and a good microphone to ensure that you're able to stream smoothly to your learners.

<Tip>
  There’s no fixed upper limit on how many live sessions you can host at the same time. Accounts
  come with a **soft limit** that can be increased at any time by reaching out to us at
  [support@codedamn.com](mailto:support@codedamn.com).
</Tip>

## Live session

You can schedule live classes in three ways at Fermion:

* **Live class inside a course:**\
  You can create a live session within a [cohort-based course](/setting-up-course/prerequisites#what-is-a-cohort-based-course%3F).   This helps you manage attendance, track progress, and keep the session part of the course flow.\
  Refer to the next section in this documentation to learn how to schedule a live class inside a course.

* **Public events:**\
  You can organize a live event that anyone can join. You can use this option for open sessions such as webinars, announcements, or community discussions.\
  [Learn more about public events](/live-classes/public-event)

* **One-on-one calls:**\
  You can set up a live session just between an instructor and an individual learner. This option can be used for personalized guidance, mentorship, or performance reviews.\
  [Learn more about 1:1 calls](/live-classes/one-one-calls)

## How to create a live class inside courses?

You can schedule live classes in [cohort based courses](/setting-up-course/prerequisites#what-is-a-cohort-based-course%3F) and go live with the help of the following steps:

<Steps>
  <Step title="Expand course items">
    Inside your syallbus section itself, click on `+ Add in this section` button to expand to all course items.

    ![+](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_4ek95Hm43J.drrsix.png)
  </Step>

  <Step title="Add a live class">
    Click on `Live class` from the available course items to add a live session.

    ![live class](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_nIvOSpjUY0.qmjnod.png)

    <Tip> You can also create a live class for your course with the help of Event calendar. For more information regarding this, refer to [Event calendar documentation](/live-classes/event-calendar) </Tip>
  </Step>

  <Step title="Enable free preview">
    If you wish to enable a free preview for your live session and generate a public invite link, click on the the three dots next to the live class and click **Enable free preview** button and provide confirmation.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_9FOuAtzxgN.hligyj.png)
    Now, you can copy this link and share with your learners.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_srvsAfqzOf.warcgr.png)
  </Step>

  <Step title="Edit the live class">
    Click on the three dots next to the newly created live session and select `Edit`.

    ![edit](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_VTYjcY3SPW.nchnvx.png)
  </Step>

  <Step title="Configure the live session">
    This will take you to a **Live Session Manager** page where you can configure a lot of the options related to this upcoming live session.

    #### Title & description

    ![title\&desc](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_H2bBnKyKmV.eybmzt.png)

    #### Session configuration

    From here, you can set the time, duration of the stream. Click on **View stats** button to access the live stream's [analytics](/live-classes/livestream-analytics)

    Additionally, you can also add external hosts via email address. When a user joins the live class with the added email address, they will have host priviledges inside the livestream, that is they'll be able to access the [whiteboard](/live-classes/whiteboard), [screenshare](/live-classes/invite-to-stage), mute participants and end the session for everyone.

    ![session config](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_BKFqgRcDjs.igwafx.png)

    #### Using other livestreaming solutions

    If you prefer to use an external livestreaming provider instead of Fermion’s in-house system, click on **Streaming Platform** and select **Other** from the dropdown menu. You can then add your call link inside the **Platform Instructions** section. These instruction will also be **automatically included** in [reminder emails](/marketing-tools/email-templates#live-event-email-reminders) sent to your participants before the session starts.

    Please note that when using an external livestreaming platform, you will not get access to **livestream recordings**, **auto-generated captions**, or **stream analytics**, as these features are only available for events hosted through Fermion’s native livestreaming solution.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_mD3JK4NSpe.ljmbcd.png)

    #### Additional settings

    You can configure the following:

    * [Recorded Playback](/live-classes/recording-and-captions): allows users to have access to the live session as a recorded video, that they can watch from their course page later.
    * **Enable Reminders**: By default, reminder emails are sent to students 24 hours, 6 hours and 30 minutes before a live session starts. [Learn how to enable reminders for all live events in your school](/marketing-tools/email-templates#live-event-email-reminders)
    * **Post-stream feedback collection**: Shows user a screen where they can submit feedback and star rating for the live session. These ratings can be accessed later at [livestream analytics](/live-classes/livestream-analytics).
    * **Allow MP4 downloads**: You can make the session recording available to students as a downloadable video for offline access .
    * [DRM playback](/live-classes/drm-and-watermarking): Turning this on will prevent users from screen recording and screenshotting your content.
    * [Enable AI transcripts](/live-classes/recording-and-captions): You can opt-in to have transcripts generated for your live session, which will be directly available during playback of your recording as closed captions.

    ![additional settings](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_5mFRvv4ZJE.oymvek.png)
  </Step>

  <Step title="Publish the live class">
    Once you are done configuring your live session, click on `Publish` to publish the live class.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_pP2LEBg9Rc.ynuada.png)
  </Step>

  <Step title="Access live sessions">
    Once you have published the class, go to `Live Sessions` from the left sidebar of your screen.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_JsrybJJH35.pphioj.png)
  </Step>

  <Step title="Start the live stream">
    Click on `Start live stream` for the live class that you have created.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-09-2025/seelen-ui_Z4FKZJWdkT.cgakcs.png)
    Instructors and added hosts can also **access and start live classes directly** from the **Live event course items** widget on their User dashboard, providing a quick way to go live without opening the Course Builder.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/hiidc4ruPk.ukedam.png)
  </Step>

  <Step title="Go live">
    Once you proceed, you will see such a screen.

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/04-01-2025/screenshot-000661%402x.xtzpea.png)

    Press on the button **Begin stream** when you want to start streaming.
    Your users on the other side (inside the course item page) will be able to watch the stream normally.
  </Step>

  <Step title="End the session">
    Once your class concludes, click on **End Session** within the live call interface to properly end the live session. This ensures your recording is processed correctly and analytics are finalized.

    <Check>
      Only **meeting hosts** can end the live class for everyone.
    </Check>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_H8kcCdHZbw.heyeax.png)
  </Step>
</Steps>

<Note>
  Closing your browser tab or window does **not** automatically end the live session on Fermion’s
  side. A session only ends when you manually end it within the call or by invoking the **[End
  API](/api-reference/live/end-live-event-streaming)**. If the live call remains completely empty
  (no participants) for **1 hour**, the system will automatically end the session for you.
</Note>

## Scheduling live classes

You can schedule your live classes in two ways: **singularly** or in **bulk** using our Event Calendar.

* **Live class Scheduling:** If you want to schedule a one-off session, you can set the date and time directly in the Event Calendar to create your live class. Learn more about this feature in [Schedule a live class in Event Calendar](/live-classes/event-calendar#how-to-schedule-a-live-session-directly-in-event-calendar)
* **Bulk scheduling:** For multiple sessions at once, you can use the Event Calendar to plan your entire course's live sessions ahead of time. This is especially helpful if you want to maintain a consistent weekly or monthly schedule. Learn more about [Bulk Schedule live classes via CSV](/live-classes/event-calendar#how-to-bulk-schedule-live-classes-via-csv)

For detailed instructions on how to use the Event Calendar, check out the [Event Calendar Documentation](/live-classes/event-calendar) for step-by-step guidance.


# Live Class on Fermion
Source: https://docs.fermion.app/live-classes/what-are-live-classes

Learn about live classes on Fermion and how to conduct them properly

Fermion offers built-in live streaming capabilities, eliminating the need for third-party applications like Zoom. This not only provides a seamless experience but also reduces additional costs and setup hassles.

Fermion's in-house live streaming infrastructure supports up to 10,000 participants in a live stream, with the option to add 50 people to the stage. This ensures a smooth, uninterrupted teaching experience, making it easier for you to focus on delivering your content effectively.

## What is a Live Class?

A Live Class is an interactive, real-time session between you and your students, powered by Fermion’s in-house streaming infrastructure.
Unlike traditional third-party integrations, Fermion’s live system is deeply integrated into the LMS, giving you full control over every aspect of the experience: from scheduling and access management to recording, playback, and host controls. You can engage your learners through [real-time chat](/live-classes/live-chat), polls, and speaker interactions, while maintaining complete content security with built-in [DRM](/live-classes/drm-and-watermarking) and [analytics](/live-classes/livestream-analytics) tracking.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_B4hlvGs6Z1.tjummi.png)

## Fermion's live infrastructure capabilities

Fermion comes with a range of powerful live class features designed to make teaching and learning more interactive, secure, and scalable. Below are some of the key capabilities available to you.

#### Upto 1080p session streaming

Fermion allows you to stream upto **1080p** to unlimited viewers, which is later made available as a recording too.

#### Unlimited students

Our systems are built and tested to support more than **10,000+ students** attending your live class at once. That means you get an experience as smooth as butter while teaching, and your students get uninterrupted learning from you.

#### Invite multiple speakers

Fermion allows you to invite up to **150 participants on stage** during a live session. Participants on stage can screenshare, turn on their microphone and camera to interact with everyone. You also have the ability to auto-add speakers to the stage. For more information, refer to: [Invite to Stage](/live-classes/invite-to-stage)

#### Pin a tile for everyone

Instructors have the ability to **'PIN' a user's tile** to the stream, ensuring students stay focused on the same view. For more information, refer to: [Pin a tile](/live-classes/pin-a-tile)
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_S7g4noVI5X.cyjxqq.png)

#### No limit on duration

There is **no restriction** on how long you can go live. You can even teach for **6+ hours** in a single session, all possible with Fermion.

#### In-built DRM support

With Fermion's **in-built DRM support**, your video content is protected from piracy and unauthorised sharing. Additionally, we offer a **video watermarking** option to identify anyone sharing or pirating your content. For more information, refer to: [DRM & Video Watermarking](/live-classes/drm-and-watermarking)

#### Auto-recording & Captions

Once your live session ends, Fermion **automatically converts it into a video recording** and makes it available to your students. Additionally, instructors can opt-in to have **AI-generated captions** created in the same language used during the live stream. For more information, refer to: [Auto-recording & Captions](/live-classes/recording-and-captions)

#### Chat live with your students

Send messages, tag people, and chat in real-time with your students. Users can send attachments, create polls to interact with everyone, and share important files. For more information, refer to: [Live Chat](/live-classes/live-chat)
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/23-10-2025/chrome_N6UDGIOu5N.dddtbl.png)

#### Interactive whiteboard

Fermion includes a **collaborative whiteboard** that allows instructors to draw, annotate, and brainstorm in real-time. You can add shapes, arrows, text, sticky notes, and even import images or screenshots to illustrate complex ideas visually. The whiteboard supports **infinite canvas** and **multi-user collaboration** making it perfect for teaching new concepts to students in a visual way.
For more information, refer to: [Whiteboard](/live-classes/whiteboard)

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_ViUZlzq4ic.lfwgsj.png)

#### Add notes & share resources after a live stream

After your live stream ends, you can **add notes, or share additional resources** with your learners directly from the session page. This makes it easy to provide follow-up material, extra insights, or answer any outstanding questions even after the session is over.

This feature is also available to **external mentors**, allowing guest speakers or industry experts who join your sessions to upload resources, slides, or answer questions for your students post-event.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_19hmfdWHCz.qhlemp.png)

#### Monitor stream analytics

Built-in **stream analytics** let you see how many students attended the stream, when they dropped off, how many messages were sent, and much more. These can be accessed from your instructor dashboard. Learn more about [Live class analytics](/live-classes/livestream-analytics)

![Livestream Stats](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_6WVsGnfPeF.wzjvcj.png)

#### White labeled embedding

You can **embed live sessions outside Fermion** using Fermion API. For details, refer to: [Live stream embedding](/live-classes/embed-live-session)

## Going live on Fermion

You can go live on Fermion in three different ways, depending on your teaching or engagement needs:

<Columns>
  <Card title="Live Classes Inside Courses" href="/live-classes/setup-live-class">
    Schedule live sessions directly within a course module.
    This is ideal for conducting classes as part of a structured learning path for enrolled learners.
  </Card>

  <Card title="Public Events" href="/live-classes/public-event">
    Host open live sessions such as webinars, community events, or workshops that anyone can join using a shareable link.
  </Card>

  <Card title="One-on-One Calls" href="/live-classes/one-one-calls">
    Conduct personalized sessions, mentorship, or feedback discussions privately with a single learner.
  </Card>
</Columns>


# Whiteboard
Source: https://docs.fermion.app/live-classes/whiteboard

Collaborate visually during live sessions with Fermion’s interactive whiteboard.

The **Whiteboard** in [live sessions](/live-classes/what-are-live-classes) is a collaborative visual canvas designed to make teaching and demonstrations more interactive and engaging. It allows instructors to visually explain concepts, sketch diagrams, highlight content, and respond to student questions in real time.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_ViUZlzq4ic.lfwgsj.png)

## Why do we need whiteboard?

Visual explanations often communicate ideas more effectively than text or speech alone. By combining the power of drawing, writing, and pointing, instructors can create an immersive learning environment that promotes clarity and real-time understanding. This makes it an essential tool for instructors who prefer to demonstrate thought processes and encourage participation.

<Check>
  The **whiteboard** is accessible to instructors and **[promoted hosts](/live-classes/invite-to-stage#promoting-users-to-hosts-during-live-session)**, allowing them to draw, annotate, and collaborate during live sessions. Regular participants can use **laser pointers** to highlight or direct attention to specific areas of the board.
</Check>

## Accessing the whiteboard

You can access the whiteboard directly from your [live session](/live-classes/setup-live-class) interface. Once inside a session, it takes only a few clicks to begin sketching and collaborating visually.

<Steps>
  <Step title="Join a live session">
    Enter your scheduled live class from the dashboard as an instructor. Learn more about how to
    [set up a live class](/live-classes/setup-live-class).
  </Step>

  <Step title="Open the whiteboard">
    Inside the livestream interface, click on the **Whiteboard toggle** located on the toolbar,
    right next to the screenshare button.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_MEe4AGvqKz.qeyegg.png)
  </Step>

  <Step title="Start drawing">
    Once enabled, you’ll see the canvas appear on your screen. Use the tools on the side panel to
    draw, add text, images, or highlight content in real time.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_47GpzBqay5.xqmwxr.png)
  </Step>

  <Step title="Student interaction">
    Students can follow your whiteboard in real time and use their laser pointers to draw attention
    to specific areas. However, they cannot modify or erase the content on the instructor’s board.
  </Step>
</Steps>

The whiteboard transforms traditional online teaching into a truly collaborative experience. It helps bridge the gap between theory and visualization, especially in technical or design-oriented classes. With live annotations, instructors can illustrate problem-solving metho

<Tip>
  **Make sure to pin your whiteboard tile** if you’re also screen sharing. This ensures the
  whiteboard remains the **primary visible content** for all participants throughout the session.
  Learn more on how to [pin a tile during live class](/live-classes/pin-a-tile).
</Tip>

## Features

The whiteboard offers a powerful and fluid real-time drawing experience, purpose-built for teaching, visual explanation, and team collaboration. Every stroke, object, and annotation is synchronized instantly across all participants, ensuring that both instructors and learners stay perfectly in sync.

### Infinite canvas

The whiteboard provides an **infinite canvas**, allowing instructors to think and teach without boundaries. You can scroll, pan, and zoom effortlessly to create multiple segments of your explanation within a single continuous space. This is especially helpful when breaking down large problems, such as multi-step algorithms or design diagrams.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_HLsvzuxSib.ikxbwm.png)

### Drawing tools and shapes

The drawing toolkit offers an intuitive experience for freehand sketches and structured shapes. You can draw using pen tools, create rectangles, circles, arrows, and even straight lines to depict flowcharts, system architectures, or visual examples.

Each element drawn can be resized and repositioned, providing full creative freedom while maintaining precision. The pen input is optimized for fluid motion and minimal latency, so it feels as natural as writing on a real whiteboard.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_FH78eU3rCr.lphprn.png)

### Text and annotations

In addition to drawing, you can insert **text boxes** anywhere on the canvas. This allows instructors to label diagrams, write notes, or define key terms without cluttering the visual explanation. Text elements can be styled with varying sizes and colors, making it easy to differentiate headings, definitions, and supporting notes.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_2zPd37d5Ep.owzgfv.png)

Annotations appear instantly across all participant screens, enabling everyone to follow the instructor’s reasoning in real time.

### Color and styling controls

To enhance visual clarity, the whiteboard includes a **color palette and styling controls**. You can switch between pen colors, adjust line thickness, and change fill properties for shapes. This flexibility helps highlight important sections, differentiate between concepts, and make diagrams more visually coherent.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_pTURSacMi0.jqqlja.png)

Using multiple colors not only improves engagement but also reinforces visual learning by emphasizing relationships between different ideas.

### Upload images onto whiteboard

Instructors can **upload images directly onto the whiteboard**, making it easier to build lessons around pre-existing visual materials. You can import diagrams, screenshots, infographics, or reference materials and annotate them live to enhance understanding.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-10-2025/chrome_13qZecq4Pz.aytvwn.png)

Uploading an image is as simple as selecting the **image icon** from the toolbar and choosing a file from your device. Once placed on the canvas, you can **resize** or **reposition** the image freely. This flexibility allows you to blend pre-prepared visuals with spontaneous drawings and notes.

### Real-time collaboration

Every interaction on the whiteboard: drawing, typing, or moving an object, is synchronized live. This real-time sync ensures that students see the instructor’s content evolve instantly, stroke by stroke, with zero noticeable delay.

<Check>
  Students can’t draw on the instructor’s board but can use laser pointers to guide attention
  toward specific areas, ask questions, or highlight doubts without disrupting the flow of
  teaching.
</Check>

This controlled interactivity promotes focus and engagement, giving students the ability to interact meaningfully while maintaining instructional control.

### Undo, redo, and erase

Mistakes are part of the creative process, and the whiteboard makes correcting them simple. The undo **\[CTRL/CMD + Z]** and redo **\[CTRL/CMD + Shift + Z]** actions allow you to step backward or forward through your edits. The **eraser tool** provides precise control for removing unwanted strokes or shapes without affecting the

## Using whiteboard on small screen devices

Fermion’s whiteboard is fully optimized for mobile and tablet devices, providing the same powerful functionality as the desktop version. Instructors and promoted hosts can draw, add text, insert images, and use shapes directly on the canvas using touch gestures or a stylus. The interface is responsive and adapts seamlessly to different screen sizes, ensuring an intuitive and smooth experience.

All features work identically on mobile, with every stroke and update synchronized instantly for all participants. This makes it easy to teach or demonstrate concepts from anywhere while keeping students fully engaged, even on smaller screens.

## Next steps

<Columns>
  <Card title="Transcripts & Auto-Recordings" href="/live-classes/recording-and-captions">
    Capture every moment of your live session automatically. Generate AI-powered transcripts and
    session recordings for learners to revisit anytime.
  </Card>

  <Card title="DRM and Video Watermarking" href="/live-classes/drm-and-watermarking">
    Protect your content with secure DRM and dynamic watermarking. Keep your intellectual property
    safe while sharing videos confidently.
  </Card>
</Columns>


# Additional Settings
Source: https://docs.fermion.app/manage-settings/additional-settings

Configure post-payment redirects, office address, custom code, and FOMO widget for your school.

The **Additional Settings** section lets you configure extra options that enhance your school’s **branding**, **compliance**, and **user engagement**.\
These settings provide flexibility for post-payment experiences, design customization, and marketing optimizations.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_bD0TGHnkDb.tidmvd.png)

You can configure the following options in this section:

***

## Post-payment success custom page URL

Redirect users to a custom webpage after they complete a successful payment.

* **Usage:** Enter the URL of a page you’ve designed within your school’s website (e.g., a “Thank you” or “Next steps” page).
* **Benefit:** Helps you personalize post-purchase experiences, promote upsells, or guide students to their first lesson.

<Tip>
  Example URL: `https://myschool.fermion.app/thank-you`\
  This page could include a welcome message, enrollment details, or a link to the user’s dashboard.
</Tip>

Learn more about creating custom pages in [Using Source Code](/custom-landing-pages/using-source-code).

***

## Physical Office Address

Add your **official business or school address** for compliance and email deliverability.

* **Purpose:** Many countries require a valid business address in transactional emails.
* **Display:** The address appears in automated communications such as payment receipts, invoices, and notifications.

<Note>
  We recommend using your organization’s registered address.\
  If you operate remotely, a valid virtual or correspondence address can also be used for compliance.
</Note>

***

## Custom Code Injection

Insert **custom JavaScript or CSS** globally across your school’s website to modify behavior, add widgets, or customize design elements.

* **Usage:** Ideal for adding analytics scripts (e.g., Google Analytics, Meta Pixel), live chat widgets, or visual styling tweaks.
* **Scope:** Injected code applies across all public-facing pages of your school.

<Check>
  Ensure your code snippets are secure and tested to avoid breaking core functionality.\
  Improper or unverified third-party scripts can impact load times or security.
</Check>

Learn more about styling your school with [Custom CSS Styling](/manage-settings/custom-css-styling).

***

## Enable Recent Sales FOMO Widget

The **Recent Sales FOMO Widget** allows you to display real-time purchase notifications on your homepage or course landing pages, helping to boost conversions through **social proof**.

By showcasing live enrollment activity, it creates a sense of urgency and builds trust among potential students, encouraging them to take action. These dynamic “Recent sales” alerts appear automatically as users browse your site, enhancing engagement and driving more enrollments. This feature can be enabled on both your home page and [Course Landing Pages](/setting-up-course/landing-page).

<Note>
  This feature can increase engagement and conversion rates, especially during limited-time promotions or course launches.
</Note>


# Billing
Source: https://docs.fermion.app/manage-settings/billing

View your current plan, monitor usage across all metrics, and review your complete transaction ledger including sales, refunds, and subscription overages.

The **Billing** page gives you a centralized view of your subscription plan, real-time usage across all platform metrics, and a complete transaction ledger. Use this page to stay informed about your plan limits, track how much of each resource you've consumed, and review every financial transaction — including sales, refunds, subscription charges, and overages.

***

## Accessing the billing page

To open the **Billing** page:

<Steps>
  <Step title="Open instructor dashboard">
    Log in to your instructor account and navigate to your **Dashboard**.
  </Step>

  <Step title="Navigate to Billing & earnings">
    In the sidebar, click **Billing & earnings** to expand the available configuration options.
  </Step>

  <Step title="Select Billing">
    Click **Billing** to open the full configuration panel.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-03-2026/Arc_kaLnVAbMp6.lxpktt.png)
  </Step>
</Steps>

***

## Current plan

The top section of the billing page displays your active subscription plan. The header shows your **plan name** (e.g., Fermion Pro (Monthly)) along with the **subscription date range** (e.g., 01 Oct 2025 – Forever).

This section is organized into two tabs:

### Plan details

The **Plan details** tab shows a summary of your plan's pricing and billing terms, followed by a full breakdown of included usage limits and overage rates.

#### Plan summary

| Field              | Description                                                                                     |
| ------------------ | ----------------------------------------------------------------------------------------------- |
| **Base amount**    | The recurring subscription price for your plan (e.g., INR 4,999).                               |
| **Cycle duration** | The length of each billing cycle (e.g., 30 days).                                               |
| **Grace period**   | The number of days after a cycle ends before overages are finalized and charged (e.g., 7 days). |

#### Usage metrics

The usage metrics table lists every metered resource included in your plan, with the amount included per billing cycle and the overage rate charged when usage exceeds the included limit.

| Metric                     | Included            | Overage                        |
| -------------------------- | ------------------- | ------------------------------ |
| **Bandwidth**              | 1 TB                | 20 USD per 1 TB                |
| **DRM**                    | 5000 playbacks      | 4 USD per 1000 playbacks       |
| **Storage**                | 100 GB              | 2.5 USD per 100 GB             |
| **Interactive Lab**        | 1000 hours          | 0.06 USD per 1 hour            |
| **DSA Lab**                | 50000 runs          | 1 USD per 3000 runs            |
| **Email**                  | 3000 emails         | 0.5 USD per 1000 emails        |
| **AI Usage**               | 1 US Dollar         | 1 USD per 1 US Dollar          |
| **Instructor Count**       | 10 individual count | 5 USD per 1 individual count   |
| **Edge Request**           | 10 million requests | 0.5 USD per 1 million requests |
| **SMS India**              | 100 SMS             | 1 USD per 100 SMS              |
| **AI Transcription Usage** | 5 hours             | 0.3 USD per 1 hour             |

<Warning>
  When usage exceeds your plan's included limit for any metric, overage charges are applied automatically at the rates shown above.
</Warning>

### Billing cycles

The **Billing cycles** tab shows a chronological history of all your past and current billing cycles.

Each row in the table displays:

| Column         | Description                                                                                |
| -------------- | ------------------------------------------------------------------------------------------ |
| **Cycle**      | The sequential billing cycle number.                                                       |
| **Start**      | The start date of the billing cycle.                                                       |
| **End**        | The end date of the billing cycle.                                                         |
| **Invoice ID** | The unique identifier for the invoice generated for that cycle.                            |
| **Status**     | The current state of the invoice — **Completed** (paid) or **Pending** (awaiting payment). |
| **Actions**    | An **Open invoice** button to view or download the invoice.                                |

<Info>
  When an invoice has a **Pending** status, you can pay for it directly from this tab by clicking the action button next to the invoice. This allows you to settle outstanding invoices without leaving the billing page.
</Info>

<Tip>
  If you wish to upgrade or change your plan, please contact [support@codedamn.com](mailto:support@codedamn.com) for available options and pricing tiers.
</Tip>

***

## Current cycle usage

Below the current plan section, the **Current cycle usage** panel shows your real-time consumption for the active billing cycle. It displays your plan name and the cycle date range (e.g., Fermion Pro (Monthly) · Mar 1, 2026 – Mar 31, 2026).

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-03-2026/Arc_Yw4CWKQoL9.pkykkw.png)

Each metric row shows:

* **Metric name**: The resource being tracked (e.g., DRM, Interactive Lab, Email, Bandwidth).
* **Included**: The amount included in your plan for the current cycle.
* **Current usage**: How much you have consumed so far.
* **Progress bar**: A visual indicator of consumption — displayed in **green** when within limits, **orange** when approaching the limit, and **red** when usage exceeds the included amount (overage).

<Warning>
  Metrics shown in red with usage exceeding the included limit indicate active overages. These will be charged at the overage rates listed in your [Plan details](#plan-details).
</Warning>

***

## Transaction ledger

The transaction ledger provides a chronological record of all transactions happening on your account — including student purchases and refunds.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-03-2026/Arc_8wyo9kY5AW.xseaew.png)

Each row in the ledger displays the following columns:

| Column        | Description                                                                                                                                                                                     |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Type**      | The kind of transaction — **user sale** (shown in green with an ↑ arrow) or **user refund** (shown in red with a ↓ arrow).                                                                      |
| **Timestamp** | The exact date and time the transaction occurred (e.g., Mar 4th, 2026 06:29 PM).                                                                                                                |
| **Details**   | The payment gateway used for the transaction (e.g., UPI, Razorpay, PayPal, Stripe) along with the user's email address. Refunded transactions display a **Refunded** badge next to the gateway. |
| **Amount**    | The transaction amount with currency (e.g., (INR) ₹8,939.94)                                                                                                                                    |

### Transaction types

| Type               | Description                                                                                                                                                                                                                                |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **User sale**      | Revenue collected from a student purchasing a course, bundle, or digital product. Displayed in green.                                                                                                                                      |
| **User refund**    | Amount returned to a student for a refunded purchase. Displayed in red.                                                                                                                                                                    |
| **Platform usage** | Automatic charges from Fermion for subscription billing, overage fees, and platform resource consumption (e.g., Overage average storage, Overage AI usage, Overage instructors count, Fermion platform subscription). Displayed in yellow. |
| **Manual topup**   | Manual payments made towards your Fermion subscription (e.g., Fermion subscription payment). Displayed in green.                                                                                                                           |

<Info>
  The ledger shows all transactions in reverse chronological order, with the most recent activity at the top. Each entry includes the payment gateway details so you can trace payments across providers like UPI, Razorpay, PayPal, and Stripe.
</Info>

***

## Next steps

<Columns>
  <Card title="Earnings" href="/manage-settings/earnings" icon="sack-dollar">
    Track your revenue, view sales trends, and export detailed reports from your earnings dashboard.
  </Card>

  <Card title="Manage Payouts" href="/manage-settings/manage-payouts" icon="money-bill-transfer">
    Configure your payout details to receive your earnings securely and on time.
  </Card>
</Columns>


# Configure and Access Basic School Settings
Source: https://docs.fermion.app/manage-settings/change-school-settings

Learn how to configure your school’s branding, login options, security, and other administrative settings.

You can manage your school’s metadata, branding, login preferences, and security settings from the **School Settings** section. You can use this area to personalize your institution’s identity, control how users log in, and fine-tune advanced configurations.

***

### Accessing school settings

To open the **School Settings** page:

<Steps>
  <Step title="Open instructor dashboard">
    Log in to your instructor account and navigate to your **Dashboard**.
  </Step>

  <Step title="Go to Settings">
    In the sidebar, click **Settings** to expand the available configuration options.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/qO9jGpNhcT.ydhnsl.png)
  </Step>

  <Step title="Select School settings">
    Click **School Settings** to open the full configuration panel where you can customize your school’s information, branding, and other options.
  </Step>
</Steps>

***

## Basic Information & Branding

Configure your school’s core details, website metadata, and visual identity.

<Note>
  If you need to change your school’s URL, please contact [support@codedamn.com](mailto:support@codedamn.com). School URLs cannot be changed manually.
</Note>

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_PdqRKDQMbD.iybuuq.png)

You can change the following details of your school here

* **Website URL**: Displays your current school URL (e.g., `https://demo.fermion.app`).
* **Website name**: Set the public display name for your school.
* **Square logo (1:1)**: Used as your favicon and brand icon on checkout.
* **Rectangle logo (16:9)**: Appears as your website’s header logo.
* **Header logo style**: Select the style of logo you wish to display on the **header**

  * **Full width logo**: Uses the rectangle image as your header logo.
  * **Square logo with text**: Uses the square image along with your site title.

  Click on **Save changes** to publish your updates in your school branding.

***

## School Settings Overview

You can also configure the following settings from the same section. Learn more about these settings by clicking on the respective card.

<Columns>
  <Card title="Login & Security" href="/manage-settings/security-settings" icon="lock">
    Manage authentication, social logins, password policies, and access control to ensure your school’s platform is secure for both learners and instructors.
  </Card>

  <Card title="Livestream and Video Settings" href="/manage-settings/live-and-recorded-settings" icon="video">
    Configure your live class and recorded video preferences, including playback quality for smooth content delivery.
  </Card>

  <Card title="Legal Settings" href="/manage-settings/legal-and-compliance" icon="file-text">
    Manage your Terms of Service and Privacy Policy documents to define user rights, responsibilities, and compliance requirements for your school.
  </Card>

  <Card title="Additional Settings" href="/manage-settings/additional-settings" icon="square-plus">
    Customize advanced options like payment redirects, physical address display, code injection, and FOMO widgets to enhance your school’s functionality and brand experience.
  </Card>
</Columns>


# Custom Styling with CSS
Source: https://docs.fermion.app/manage-settings/custom-css-styling

Learn how to customize the appearance of Fermion components using custom CSS selectors

Fermion provides a flexible way to customize the appearance of various components on its platform. By utilizing specific data attribute selectors, you can inject custom CSS to modify the default styles. This guide outlines the available selectors and demonstrates how to use them effectively.

## How to Apply Custom CSS

To apply custom CSS to Fermion components, use the `data-custom-css-class` attribute with the appropriate selector. Here's the general syntax:

```css theme={null}
[data-custom-css-class='selector-name'] {
	/* Your custom CSS properties here */
}
```

## Example

This example changes the background color of the completed lessons' checkbox to green in the course items.

```css theme={null}
[data-custom-css-class='course-item-mark-as-not-done-checkbox'] {
	background-color: 'darkgreen';
}
```

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/08/07224533/Screenshot-2024-08-07-at-10.45.15%E2%80%AFPM-1024x566.png)

## Currently Available Selectors

Below, we present a list of available values for the `data-custom-css-class` attribute that target specific locations on the Fermion platform.

### Course Item Views

* `[data-custom-css-class="course-item-video"]` - Targets video lessons
* `[data-custom-css-class="course-item-quiz"]` - Targets quiz items
* `[data-custom-css-class="course-item-article"]` - Targets article/read-only items
* `[data-custom-css-class="course-item-ebook"]` - Targets embedded eBooks
* `[data-custom-css-class="course-item-contest"]` - Targets contest/problem items
* `[data-custom-css-class="course-item-scorm"]` - Targets SCORM packages
* `[data-custom-css-class="course-item-assignment"]` - Targets assignment/homework items
* `[data-custom-css-class="course-item-iframe-embed"]` - Targets generic iframe embeds
* `[data-custom-css-class="course-item-coding-lab"]` - Targets coding lab items
* `[data-custom-css-class="course-item-live-event-fermion"]` - Targets Fermion live events
* `[data-custom-css-class="course-item-live-class-fermion"]` - Targets Fermion live classes
* `[data-custom-css-class="course-item-live-class-other"]` - Targets non-Fermion live classes

### Header Logo (Course Landing Page)

* `[data-custom-css-class="header-logo-course-landing-page-desktop"]`
* `[data-custom-css-class="header-logo-course-landing-page-mobile"]`

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/08/06140125/Screenshot-2024-08-06-at-1.58.31%E2%80%AFPM-1024x331.png)

### Header Logo (Website Pages)

* `[data-custom-css-class="header-logo-homepage-page-desktop"]`
* `[data-custom-css-class="header-logo-homepage-page-mobile"]`

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/08/06133120/header-1024x678.png)

### Header Logo (Product Landing Page)

* `[data-custom-css-class="header-logo-product-landing-page-desktop"]`
* `[data-custom-css-class="header-logo-product-landing-page-mobile"]`

### Learning Page

* `[data-custom-css-class="course-item-mark-as-done-checkbox"]` - Targets the control to mark an item as complete
* `[data-custom-css-class="course-item-mark-as-not-done-checkbox"]` - Targets the control to mark an item as incomplete

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/08/06134213/Screenshot-2024-08-06-at-1.40.21%E2%80%AFPM-1024x792.png)

### Learning Page (Sidebar Header)

* `[data-custom-css-class="header-logo-course-item-sidebar-mobile"]`
* `[data-custom-css-class="header-logo-course-item-sidebar-desktop"]`

![](https://codedamn-blog.s3.amazonaws.com/wp-content/uploads/2024/08/06140346/Screenshot-2024-08-06-at-1.40.21%E2%80%AFPM-1-1024x515.png)

### Learning Page (Content Side)

* `[data-custom-css-class="course-item-main-area"]` - This selector is the topmost parent class of the area where the user sees course item content.

### Course Item Layout/Wrappers

* `[data-custom-css-class="course-item-main-area"]` - Outer wrapper for the current course item content

### Course Landing Page Sections

* `[data-custom-css-class="instructor-section-top"]` - Top instructor information block
* `[data-custom-css-class="instructor-section-bottom"]` - Bottom instructor information block
* `[data-custom-css-class="course-hero-section"]` - Hero/header section of the course page
* `[data-custom-css-class="course-content-sections"]` - Main content/what-you'll-learn sections
* `[data-custom-css-class="course-reviews-grid"]` - Reviews/testimonials grid container
* `[data-custom-css-class="course-faqs-container"]` - FAQs accordion/container

### Dynamic State and Type Marker

Pattern: `course-item--state-${complete|incomplete}--type-${lowercase(item.type)}-v2`

* Use exact values to target specific combinations, for example:

```css theme={null}
[data-custom-css-class='course-item--state-complete--type-video-v2'] {
	/* Your custom CSS for completed video items */
}

[data-custom-css-class='course-item--state-incomplete--type-quiz-v2'] {
	/* Your custom CSS for incomplete quiz items */
}
```

### Authentication Pages

* `[data-custom-css-class="login-page"]` - Targets the login page at `/login`. Use this to customize background, fonts, and overall styling of the login page.
* `[data-custom-css-class="logout-page"]` - Targets the logout page at `/logout`. Use this to customize page-level visuals while logging out.
* `[data-custom-css-class="register-page"]` - Targets the registration page at `/register`. Use this to customize background, fonts, and overall styling of the registration page.
* `[data-custom-css-class="password-reset-page"]` - Targets the password reset page at `/password-reset`. Use this to customize background, fonts, and overall styling of the password reset page.

### Complete Example Configuration

Here's a comprehensive example showing how to customize authentication pages with custom CSS(currently supports upto 20,000 characters for custom code injection):

```html theme={null}
<style>
	/* Login page customization */
	[data-custom-css-class='login-page'] {
		background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
		font-family: 'Inter', sans-serif;
	}

	[data-custom-css-class='login-page'] .login-form {
		background: rgba(255, 255, 255, 0.95);
		border-radius: 12px;
		box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
	}

	/* Registration page customization */
	[data-custom-css-class='register-page'] {
		background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
		font-family: 'Poppins', sans-serif;
	}

	[data-custom-css-class='register-page'] .register-form {
		background: rgba(255, 255, 255, 0.9);
		border-radius: 16px;
		box-shadow: 0 12px 40px rgba(0, 0, 0, 0.15);
	}

	/* Password reset page customization */
	[data-custom-css-class='password-reset-page'] {
		background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
		font-family: 'Roboto', sans-serif;
	}

	[data-custom-css-class='password-reset-page'] .reset-form {
		background: rgba(255, 255, 255, 0.92);
		border-radius: 10px;
		box-shadow: 0 6px 24px rgba(0, 0, 0, 0.12);
	}

	/* Common button styling for all auth pages */
	[data-custom-css-class='login-page'] button,
	[data-custom-css-class='register-page'] button,
	[data-custom-css-class='password-reset-page'] button {
		background: linear-gradient(45deg, #667eea, #764ba2);
		border: none;
		border-radius: 8px;
		color: white;
		font-weight: 600;
		padding: 12px 24px;
		transition: all 0.3s ease;
	}

	[data-custom-css-class='login-page'] button:hover,
	[data-custom-css-class='register-page'] button:hover,
	[data-custom-css-class='password-reset-page'] button:hover {
		transform: translateY(-2px);
		box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
	}
</style>
```

## Best Practices

1. **Specificity**: When using these selectors, ensure your CSS rules are specific enough to override the default styles without affecting other elements unintentionally.

2. **Responsive Design**: Consider both desktop and mobile selectors when making changes to ensure a consistent experience across devices.

3. **Testing**: Always test your custom CSS on various screen sizes and browsers to ensure compatibility and proper rendering.

## How to Access Custom CSS Settings

To apply custom CSS to your Fermion platform:

1. Navigate to your Fermion dashboard
2. Go to **School Settings**
3. Scroll down to find the **Custom Code Injection** section
4. Add your CSS code in the provided text area inside `<style>` tag
5. Click **Save** to apply the changes

By leveraging these custom CSS selectors, you can tailor the Fermion platform to match your brand identity or specific design requirements. Remember to use these customization options judiciously to maintain a cohesive and user-friendly interface throughout your courses and website.

For any further customization needs or questions about implementing these CSS modifications, please refer to the Fermion documentation or contact the support team.


# Custom Sidebar Links
Source: https://docs.fermion.app/manage-settings/custom-links

Instructors can add **custom links** to your **User Dashboard sidebar**.

Custom sidebar links allow instructors to personalize the **User Dashboard sidebar** by adding links to any resources, tools,
or documentation that students frequently need. This feature makes navigation faster and more intuitive,
giving students direct access to important materials without having to hunt through emails or separate platforms.

You can use Custom Links for anything from scheduling third party events, linking to guides or assignments, integrating external tools, or providing quick access to your team’s resources - all right from the user dashboard.

## How to add a custom sidebar link

Follow these steps to add a custom link in your user dashboard sidebar

<Steps>
  <Step title="Go to user dashboard settings">
    Navigate to **Settings** → **User Dashboard** in your sidebar.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_v8SYVrVfqG.jhxsja.png)
  </Step>

  <Step title="Add a new link">
    Click **Add another link** to create a new custom link.
  </Step>

  <Step title="Enter link details">
    Provide the **Link Label** and **Link URL** for the new link.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/chrome_KmFsFoIpNx.xitykd.png)
  </Step>

  <Step title="Save changes">
    Click **Save Changes** to publish the custom links.
  </Step>

  <Step title="Preview the dashboard">
    Preview the new user dashboard by clicking the **Open user dashboard** button.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_jZMkx15UAD.mugbsp.png)
  </Step>
</Steps>

***

## Hide the 'Back to homepage' button

If you want a more focused user dashboard, you can choose to hide the **Back to homepage** button for students.
Toggle the **Hide Back to homepage button** setting while editing your user dashboard links.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/30-12-2025/Arc_7rbetMpkpx.jektes.png)

## Next steps

<Columns>
  <Card title="Email Log" href="/manage-settings/email-log">
    View and track all emails sent from your platform.
  </Card>

  <Card title="Manage Features" href="/manage-settings/manage-features">
    Enable or disable features for your school, and configure your platform’s available functionalities.
  </Card>
</Columns>


# Earnings
Source: https://docs.fermion.app/manage-settings/earnings

Learn how to manage your payouts, track revenue, and export sales data from your earnings dashboard.

The earnings dashboard gives you a complete picture of how your sales evolve over time. It automatically aggregates revenue from all your products, including [courses](/setting-up-course/prerequisites), [bundles](/setting-up-course/bundle), or [digital products](/digital-products/introduction), and displays them in a clear, date-based chart. This helps you visualize your earning patterns, track daily or weekly performance, and identify trends such as spikes in sales during promotions or new course launches.

Along with visual insights, the dashboard provides detailed figures like total sales count, total revenue in a selected date range, and transaction summaries. These numbers update automatically as new sales occur, giving you real-time insights without needing to refresh or recalculate anything manually.

## Accessing the earnings dashboard

Follow these steps to access your earnings page:

<Steps>
  <Step title="Open Instructor Dashboard">
    After logging in to your school, navigate to your **Instructor Dashboard**.
  </Step>

  <Step title="Find billing & earnings">
    In the sidebar menu, scroll down to the **Billing and Earnings** section.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_a2TW8JIqml.sotaya.png)
  </Step>

  <Step title="Click on earnings">
    Select **Earnings** to open your earnings dashboard.
  </Step>
</Steps>

***

## Revenue overview

The top section of your earnings dashboard displays your revenue trends and total sales within a selected date range.

<Info>
  You can easily switch the date range (for example, **Oct 8 - Oct 22, 2025**) to see how your income changes over time.
</Info>

You’ll see the following details:

* **Revenue in Range**: The total revenue generated within the selected period.
  Example: `₹56000` for Oct 8 - Oct 22, 2025.
* **Total Sales**: The total number of successful purchases.
  Example: `79 sales`.
* **Chart Date Range**: The period shown in the revenue graph.
* **Revenue Graph**: Visual representation of your daily revenue growth.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_kMhXgvgOfw.ynmgby.png)

The chart allows you to track your earnings trends by date, helping you identify your best-performing days and products.

***

## Export reports (sales & no sales)

You can export sales and user data from your earnings dashboard for accounting, compliance, or analytics purposes. Here’s how to access and use the export functionality:

<Steps>
  <Step title="Navigate to export reports">
    Go to **Billings & earnings**  →  **Earnings**  →  select the **Exports** tab.<br />
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_bUn9DtWoGS.qqbnvd.png)
  </Step>

  <Step title="Choose export type">
    Use the **Export Type** dropdown to pick the kind of report you want to download:
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_5LjBSMf2ac.tdrqrv.png)

    <ul>
      <li>
        <b>Users with no purchase</b> – Export a list of all registered users who have not made any purchases.
      </li>

      <li>
        <b>Sales data</b> – Export all sales for a date range. Selecting this shows more options:

        <ul>
          <li><strong>Select Date Range:</strong> Pick the start and end dates for your sales data export.</li>
          <li><strong>Include invoice downloads:</strong> (optional) Check this box to include PDF invoices in your export.</li>
        </ul>
      </li>
    </ul>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_ez7tubai9r.gwwung.png)
  </Step>

  <Step title="Create and download export">
    Click **Create Export**.<br />

    * For <strong>Sales data</strong>: You’ll receive a ZIP containing a CSV of your sales report, and if selected, PDF invoices for all sales in the period.<br />
    * For <strong>Users with no purchase</strong>: You’ll receive a CSV with all users who have not purchased anything on your school.
  </Step>

  <Step title="Access export history">
    In the **Exports** tab, you'll see a list of previous exports under **Export History**.<br />
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_DPZq0qFYQ4.lufwrj.png)

    <ul>
      <li>Locate the report you want to download in the history list (sorted by date and type).</li>
      <li>Click the download icon next to the completed export to get your file.</li>
      <li>If the export is in progress, you’ll see a loading indicator—wait for it to complete before downloading.</li>
    </ul>
  </Step>
</Steps>

<Note>
  Use exports for reconciling payments, tax compliance, deeper analysis, or to retarget users who haven't made a purchase.
</Note>

***

## Realtime sales

The Realtime Sales section lists your most recent transactions (up to the last 50 sales) in real time.
This view helps you stay up to date with every purchase that happens on your platform without waiting for daily summaries or exports.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/rb0QSaFqnJ.wjysjb.png)

Each record displays key information about a sale: including the buyer’s name, purchase time, product purchased, invoice link, and payment status. You can use this list to quickly review who made a purchase, confirm successful payments, or troubleshoot any failed transactions. Each row also includes a direct link to download the invoice, making it easy to manage refunds or verify payment records.

| Field             | Description                                       |
| ----------------- | ------------------------------------------------- |
| **Name**          | The name of the user.                             |
| **Purchase Time** | The exact date and time the sale occurred.        |
| **Product**       | The course, bundle, or digital product purchased. |
| **Invoice**       | A downloadable link to the invoice.               |
| **Status**        | Status of the sale made                           |

## Next steps

<Columns>
  <Card title="Manage Payouts" href="/manage-settings/manage-payouts">
    Configure your payout details to receive your earnings securely and on time.
  </Card>
</Columns>

***


# Email Log
Source: https://docs.fermion.app/manage-settings/email-log

Review all emails sent from your school, including delivery status, recipients, and timestamps.

The Email Log displays a list of all outbound emails sent from your school, including notifications, [announcements](/setting-up-course/announcements), [email marketing](/marketing-tools/email-marketing) invitations, and system messages. You can use this log to review delivery status, recipients, subject lines, and timestamps for each email.
The **Email Log** gives you full visibility into your school’s communications. You can search, filter, and review every email sent to your students and instructors, helping you ensure successful delivery and follow-up where needed.

## Accessing the email log

You can access the email log of your school with the help of the following steps:

<Steps>
  <Step title="Navigate to settings">
    In your instructor dashboard sidebar, go to **Settings → Email Log**. This will open the email log dashboard where you can view all sent emails.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_EtbIsdpGH0.asldkk.png)
  </Step>

  <Step title="Search and filter emails">
    Use the search bar to filter emails by:

    * **Recipient Email**: Enter the exact email address of the recipient.
    * **Subject**: Search emails by subject line.
  </Step>
</Steps>

## Email log overview

Once you are in the **Email Log**, you can view detailed information about each email sent:

* **Sent At** : The date and time when the email was sent.
* **From** : The sender’s email address.
* **To** : The recipient’s email address.
* **Subject** : The subject line of the email.
* **Status** : Displays whether the email has been opened or unread.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/pb7pDXzZoe.dqpjsl.png)

## Why do you need email logs?

The Email Log is an essential tool for managing and monitoring all communications sent from your school. It provides complete visibility into email delivery, helping you ensure that important messages reach students and instructors reliably.

By tracking email status: whether opened or unread, you can identify potential delivery issues and take corrective action quickly. Maintaining a centralized record of all emails also supports compliance, internal audits, and troubleshooting, while giving insights into engagement to improve communication strategies. Ultimately, the Email Log helps you maintain professional, transparent, and effective communication across your school.

## Next steps

<Columns>
  <Card title="Email marketing" href="/marketing-tools/email-marketing">
    Manage your email campaigns to engage students and instructors effectively.
  </Card>

  <Card title="Email announcements" href="/setting-up-course/announcements">
    Communicate important updates via announcements to all course participants.
  </Card>
</Columns>


# Import Users
Source: https://docs.fermion.app/manage-settings/import-users

Learn how to manually enroll new users into your school using single-user or CSV import options.

You can manually enroll users into your school without requiring them to sign up themselves. It ensures that everyone gets timely access to their [courses](/setting-up-course/prerequisites), and it eliminates the need for users to go through the sign-up process manually. You can also pre-assign users to specific groups, auto-enroll them into [bundles](/setting-up-course/bundle), and send welcome [emails](/marketing-tools/email-marketing) automatically to streamline the onboarding experience.

### Why importing users matters

Importing users helps you maintain a **smooth, organized onboarding experience**. It allows you to:

* Enroll learners before a program or course begins.
* Give select users access to private or internal content.
* Centralize data when migrating from another LMS or platform.
* Ensure a consistent experience by pre-configuring access, groups, and emails.

By setting up users manually or via CSV, you ensure that everyone is properly enrolled and ready to learn from day one, without confusion or missing credentials. It’s a small administrative step that can greatly improve efficiency and the overall user experience.

## How to manually enroll users

You can enroll users into your school with the help of the following steps:

<Steps>
  <Step title="Go to the Import Users page">
    From your **Instructor Dashboard**, navigate to **Users → Import Users** in the sidebar.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_FtVeDYxlYN.dfizzf.png)\
    This is where you can add new users manually or import them in bulk using a CSV file.
  </Step>

  <Step title="Choose your import method">
    You can import users in two ways:

    * **Single user import**: add one user manually.
    * **CSV import**: upload a file containing multiple user records.
  </Step>

  <Step title="Single user import">
    When adding a single user, fill out the following fields:

    | Field                       | Description                                      |
    | --------------------------- | ------------------------------------------------ |
    | **Name**                    | User’s full name (e.g. John Doe)                 |
    | **Email**                   | User’s email address (required)                  |
    | **Phone Number**            | Optional, used for communication or verification |
    | **Password**                | Optional, leave blank to auto-generate one       |
    | **User Creation Timestamp** | Optional, set a custom creation date             |

    You can also configure additional options:

    * **Welcome Email**: Send users their credentials and access details automatically.
    * **Auto-enroll in Products**: Grant users access to selected courses or products upon import. Select the products after toggling this option to add the user into the respective product
    * **Add to Groups**: Assign users to existing user groups or create a new one directly from this page.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_UuXwDjVN9D.ezddgw.png)

    Once done, click **Add Single User** to complete the enrollment.
  </Step>

  <Step title="CSV import">
    For adding multiple users at once, use the **CSV Import** option.

    **CSV Import Instructions:**
    Upload a CSV file containing columns for user data.\
    After uploading, you’ll be able to **map your CSV columns** to the required fields.

    **Available columns:**

    * `Email`: User’s email address (**required**)
    * `Name`: User’s full name (optional)
    * `Password`: User’s password (optional; will be auto-generated if blank)
    * `Phone Number`:User’s phone number (optional)
    * `Created At`: User creation timestamp (optional)

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_YDq8BO9FJV.fffpcx.png)
  </Step>

  <Step title="Map the columns with the respective fields">
    Once your CSV file is uploaded, you’ll see a **mapping interface** where you can match each CSV column to a field in your school’s user database.

    For example, if your CSV file uses a column labeled “Student Name,” you can map it to the **Name** field, and if the column is called “Email Id,” map it to the **Email** field.\
    This ensures that your imported data aligns correctly with the platform.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/image%20\(1\).rwirnf.png)

    You can also configure additional options:

    * **Welcome email**: Send users their credentials and access details automatically.
    * **Auto-enroll in products**: Grant users access to selected courses or products upon import. Select the products after toggling this option to add the user into the respective product
    * **Add to groups**: Assign users to existing user groups or create a new one directly from this page.
  </Step>
</Steps>

And there you go, your users are now a part of your Fermion school and can be enrolled into products.


# Invoice settings
Source: https://docs.fermion.app/manage-settings/invoice-settings

Customize the footer of your sales invoices

The **Invoice settings** section allows you to customize the footer text that appears on all sales invoices sent to students upon purchase. This helps you add important legal information, terms, or branding messages to your invoices.

***

## Accessing Invoice settings

To open the **Invoice settings** page:

<Steps>
  <Step title="Open instructor dashboard">
    Log in to your instructor account and navigate to your **Dashboard**.
  </Step>

  <Step title="Go to Settings">
    In the sidebar, click **Settings** to expand the available configuration options.
  </Step>

  <Step title="Select School settings">
    Click **School Settings** to open the full configuration panel.
  </Step>

  <Step title="Navigate to Invoice settings">
    Scroll down or use the quick navigation sidebar to find and click **Invoice settings**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_7DdbLnwopu.yancpk.png)
  </Step>
</Steps>

***

## Invoice Footer Text

Customize the text that appears at the bottom of all your sales invoices.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-12-2025/Arc_oMDzEo1qjd.iamewv.png)

### Configure invoice footer

* **Invoice footer text**: Enter custom text that will appear at the bottom of all sales invoices sent to students upon purchase.
* **Character limit**: Maximum 500 characters.
* **Placeholder example**: "e.g., By purchasing this product, you agree to our Terms & Conditions."

<Note>
  The data added here will show up at the bottom of all your sales invoices. This is useful for adding legal disclaimers, terms and conditions references, or any other important information you want to include on every invoice.
</Note>

### Best practices

* Keep the text concise and professional.
* Include references to your Terms of Service or Privacy Policy if applicable.
* Add any required legal disclaimers or compliance information.
* Consider including contact information for invoice-related inquiries.

After entering your invoice footer text, click **Save changes** to apply the updates to all future invoices.


# Legal & Compliance Settings
Source: https://docs.fermion.app/manage-settings/legal-and-compliance

Manage your Terms of Service and Privacy Policy pages to ensure legal compliance and transparency.

The **Legal Settings** section helps you define the legal and compliance documents that govern how users interact with your school.\
Here, administrators can edit and publish the **Terms of Service** and **Privacy Policy** directly from the dashboard using a rich text editor.

Keeping these documents updated ensures compliance with data protection laws and maintains trust with learners and instructors.

***

## Terms of Service

Define the rules, obligations, and acceptable use guidelines for your school’s platform.

A **Terms of Service (ToS)** sets clear expectations between your school and its users. It protects your organization from misuse, defines user rights, and outlines your liability limits.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_HVjBcmLLeW.fjwrkx.png)

### Why ToS matters

* **Legal protection**: Limits your liability for user-generated content and misuse.
* **Transparency**: Ensures users understand your rules, refund policies, and acceptable behavior.
* **Enforceability**: Provides a framework for dispute resolution.
* **Professionalism**: Builds user confidence by showing operational integrity.

<Info>
  Your Terms of Service will be publicly accessible at **`/terms-of-service`** on your school’s website.
</Info>

### Editing your ToS

The editor supports **rich text formatting**, allowing you to:

* Style text (bold, italics, headings, lists)
* Insert **images** and **hyperlinks**
* Add **markdown** or **code blocks**
* Embed relevant media or sections

***

## Privacy Policy

The **Privacy Policy** defines how your school collects, stores, and uses user data.\
It is a legal requirement in most jurisdictions and helps you maintain compliance with laws such as GDPR, CCPA, and India’s DPDP Act.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_4norjA29ON.mfseix.png)

### Why it’s important

* **Transparency**: Clearly communicates what data is collected and why.
* **User trust**: Helps reassure users their information is handled responsibly.
* **Compliance**: Satisfies regulatory obligations for operating an online learning platform.
* **Accountability**: Demonstrates your school’s commitment to data protection.

<Info>
  Your Privacy Policy will be publicly available at **`/privacy-policy`** on your school’s website.
</Info>

### Editing your Privacy Policy

The editor provides a full-featured **rich text interface** similar to the ToS editor.

You can:

* Format content using text styles and headings
* Add links to external policies (e.g., payment gateways or third-party tools)
* Insert tables or bullet lists for data categories
* Embed relevant contact information for data requests


# Livestreaming & Recorded Video Settings
Source: https://docs.fermion.app/manage-settings/live-and-recorded-settings

Configure live session recording, playback behavior, and AI transcription for your school.

These settings let you control how your live sessions and uploaded videos are processed, recorded, and displayed to users.\
You can define default behaviors for **live broadcasts**, **recorded videos**, and **AI-powered transcription**.

***

## Livestreaming Settings

Configure how [livestreaming sessions](/live-classes/what-are-live-classes) are [recorded](/live-classes/recording-and-captions) and displayed to your learners.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_QI7pGvdfIu.hzkfeo.png)

### Available options

* **Enable HD recording**\
  Record live sessions in **high-definition quality**. Disabling this option will save bandwidth and storage but reduce video clarity.

  <Note>
    HD recordings consume more bandwidth and may increase processing time for large sessions.
  </Note>

* **Always stick to edge**\
  Prevent students from seeking backward during a live stream. When this option is disabled (default), viewers can freely rewind or jump forward in the live timeline.

  <Check>
    This feature is ideal for **real-time interactive classes** where you want everyone to stay synchronized with the instructor.
  </Check>

* **Generate AI transcripts automatically**\
  Automatically generate **[AI-powered transcripts](/live-classes/recording-and-captions)** once a livestream ends. This feature helps students review session content easily and improves accessibility.

  <Note>
    This is a **chargeable feature**. Refer to the [Fermion pricing](https://fermion.app/pricing) page for details.
  </Note>

  You can also enable this setting on a **per-stream basis** inside [Courses](/setting-up-course/prerequisites) → **Live Events** → **Edit Session**.

* **Automatically add everyone on stage**\
  Start live calls with all participants already on [stage](/live-classes/invite-to-stage). By default, live sessions begin in a webinar-style mode where attendees must be invited to turn on their mic or camera.

  <Check>
    Use this setting for **interactive classrooms or group discussions** where everyone should have speaking privileges from the start.
  </Check>

***

## Recorded Video Settings

Customize playback, access, and AI transcript behavior for your uploaded or recorded videos.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_xzevxzFVOt.bhqhga.png)

### Available options

* **Generate AI transcripts automatically**\
  Automatically create [transcripts and captions](/recorded-videos/captions) for recorded videos.

  <Note>
    This is a **chargeable feature**. Learn more at [Fermion pricing](https://fermion.app/pricing).
  </Note>

* **Whitelisted playback origin**\
  Restrict video embedding and playback to specific authorized domains (e.g., `https://example.com`). This prevents unauthorized sharing or embedding of your videos on other websites.

  <Example>
    If your school website is hosted at `https://myschool.fermion.app`, you can add that domain to ensure playback only works there.
  </Example>

***

## Best Practices

* Enable **AI transcription** for accessibility and quick post-class content review.
* Use **“Always stick to edge”** for synchronous teaching formats (e.g., live lectures, webinars).
* Limit **whitelisted playback origins** to prevent content piracy.
* For courses with multiple instructors, use **“Automatically add everyone on stage”** to reduce session setup time.

***


# Manage Features
Source: https://docs.fermion.app/manage-settings/manage-features

Learn how to enable, disable, and configure various features available to instructors on the platform.

Fermion provides a comprehensive suite of features that you can enable or disable based on your specific needs. These features are organized into categories to help you understand and manage your platform's capabilities effectively.

<Info>
  Some features are disabled by default. You need to manually enable the features you want to use for your online academy.
</Info>

## How to enable/disable features

<Steps>
  <Step title="Navigate to Manage features">
    Go to your **Instructor Dashboard → Manage features**.
    ![Manage features](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_79ohCnOkpc.qaneul.png)
  </Step>

  <Step title="Enable features">
    Click on `Enabled` for any feature you wish to turn on for your school.
    ![Enable features](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/Arc_zFkX5fmFYl.trgoik.png)
  </Step>

  <Step title="Save changes">
    Once you are done toggling all the features you need and don't need for your school, click on save changes.
    ![Save Changes](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/Arc_aM5osz1bGH.ltaddx.png)
  </Step>
</Steps>

# Feature overview

Fermion offers a complete suite of tools to build, market, and manage your online academy.\
Browse through the following feature categories to learn more.

You can enable all the following features from the **Manage Feature** section in your instructor dashboard. Click on any of these cards to learn more about that particular feature.

## Content features

<Columns>
  <Card title="Blogs" href="/custom-landing-pages/blogs">
    Publish articles, tutorials, and updates to engage learners beyond courses.
  </Card>

  <Card title="Courses" href="/setting-up-course/prerequisites">
    Create structured learning paths with videos, assignments, and quizzes.
  </Card>

  <Card title="Bundles" href="/setting-up-course/bundle">
    Combine multiple courses, eBooks, and live events into curated packages.
  </Card>

  <Card title="Coding Labs" href="/creating-coding-labs/what-are-coding-labs">
    Provide browser-based, interactive coding environments for students.
  </Card>

  <Card title="Forms" href="/forms/introduction">
    Collect feedback, registrations, or custom information with multi-step forms.
  </Card>

  <Card title="Online Compiler" href="/creating-io-coding-labs/compile-api">
    Allow students to write and run code directly inside your platform.
  </Card>

  <Card title="Video Library" href="/recorded-videos/introduction">
    Manage and organize video content with captions, watermarking, and embedding.
  </Card>
</Columns>

***

## Marketing features

<Columns>
  <Card title="Affiliate Marketing" href="/marketing-tools/affiliate-marketing">
    Launch an affiliate program with automated tracking and payouts.
  </Card>

  <Card title="Analytics" href="/manage-settings/school-analytics">
    Measure engagement, conversions, and revenue with advanced analytics.
  </Card>

  <Card title="Email Marketing" href="/marketing-tools/email-automation">
    Automate email campaigns and updates to keep students engaged.
  </Card>

  <Card title="WhatsApp Marketing" href="/marketing-tools/whatsapp-marketing">
    Send promotions and course updates directly via WhatsApp.
  </Card>
</Columns>

***

## Commerce features

<Columns>
  <Card title="Custom Payment Gateways" href="/setup-pricing/payment-gateway">
    Integrate and manage multiple payment providers securely.
  </Card>

  <Card title="Custom Payment Links" href="/setup-pricing/custom-payment-links">
    Generate branded payment links for direct sales from end user.
  </Card>

  <Card title="Digital Products" href="/digital-products/introduction">
    Sell eBooks and downloadable content with secure delivery and watermarking.
  </Card>
</Columns>

***

## Platform features

<Columns>
  <Card title="Custom Website" href="/custom-landing-pages/introduction">
    Build and design your academy’s website with full customization.
  </Card>

  <Card title="New User Registration">
    Control signup flows, verification, and approvals for new learners.
  </Card>
</Columns>

***

## Communication

<Columns>
  <Card title="Live Sessions" href="/live-classes/what-are-live-classes">
    Host live classes with chat, screen sharing, and auto-recording.
  </Card>

  <Card title="1:1 Calls" href="/live-classes/one-one-calls">
    Conduct personalized one-on-one sessions with learners for mentorship, feedback, or doubt resolution.
  </Card>
</Columns>

***

## Engagement

<Columns>
  <Card title="Community" href="/community/what-are-communities">
    Build discussion spaces and connect learners through posts and polls.
  </Card>
</Columns>

## Assessment & gamification

<Columns>
  <Card title="Contests" href="/contests/introduction">
    Organize coding contests and assessments to evaluate learners.
  </Card>

  <Card title="Gamification" href="/gamification/introduction">
    Motivate learners using points, badges, and leaderboards.
  </Card>
</Columns>

***

## Storage & development

<Columns>
  <Card title="Object Storage" href="/digital-products/object-storage">
    Securely store course materials and media files for distribution across your school.
  </Card>

  <Card title="Webhooks" href="/webhooks/what-is-webhook">
    Connect external systems using real-time event notifications.
  </Card>
</Columns>

***

## Branding

<Columns>
  <Card title="Remove Fermion Branding">
    White-label your academy with your own colors, logo, and identity.
  </Card>
</Columns>

<Warning>
  Some features may require separate activation or configuration after enabling.\
  Refer to each feature’s detailed documentation to complete setup.
</Warning>

## Feature Dependencies

Some features work well when other features are enabled in your school

<Columns>
  <Card title="Bundles + Courses" href="/setting-up-course/bundle">
    Bundles work best when paired with Courses, eBooks, or Live Sessions.
  </Card>

  <Card title="Affiliate Marketing + Products" href="/marketing-tools/affiliate-marketing">
    Requires Courses or Digital Products to be available.
  </Card>

  <Card title="Community + Courses" href="/community/what-are-communities">
    Works best when combined with Courses or Live Sessions.
  </Card>

  <Card title="Webhooks + Integrations" href="/webhooks/what-is-webhook">
    Can be used with any feature to automate workflows and integrations.
  </Card>
</Columns>


# Manage Instructors
Source: https://docs.fermion.app/manage-settings/manage-instructors

Add, remove, and customize instructor access and permissions for your Fermion school.

You can easily manage your school's instructor team by adding new instructors, editing their profiles, adjusting permissions, or revoking access in the **Manage instructor** section of the **Settings** tab. This feature allows you to maintain control over who can access and teach in your school while keeping your instructor list organized and up-to-date.

You can view important metrics such as the **total number of instructors**, **active instructors**, and **revoked access** directly from the instructor management panel.

***

## Manage school instructors

You can access the **Manage instructor** section with the help of the following steps:

<Steps>
  <Step title="Navigate to Settings">
    In your sidebar, go to **Settings → Manage Instructors**. This will open the instructor management dashboard.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_yd3t1FnvkR.txlbaw.png)
  </Step>

  <Step title="View Instructor Overview">
    On the dashboard, you will see key metrics:

    * **Total Instructors**: Total number of instructors in your school.
    * **Active Instructors**: Instructors currently with access.
    * **Revoked Access**: Instructors whose access has been revoked.
  </Step>
</Steps>

## Create new instructor

Managing your school's instructors is simple and efficient. You can add new instructors, update their profiles, adjust their permissions, or revoke access when needed. This ensures that only authorized instructors have access to your school's resources, keeping your team organized and your school secure.

<Steps>
  <Step title="Add a new instructor">
    In the **Instructor Management** dashboard, click **Add New Instructor**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_YsCkAVALWP.yuavjn.png)
  </Step>

  <Step title="Fill the instructor details">
    Fill in the required details:

    * **Full Name**: Enter the instructor's full name.
    * **Email Address**: Enter the instructor's email (e.g., [instructor@example.com](mailto:instructor@example.com)).
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_zQqMuYYGL6.tnptdg.png)
      Now, Click **Create instructor** to add the instructor to your school .
  </Step>
</Steps>

## Edit instructor profile

From this page, you can also manually edit certain details of an instructor profile, such as their **name**, **profile picture**, **tagline**, and **long description**.
![Edit Instructor Details](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_ZsVi2cWsaD.ievzqc.png)

You will now see a form where you can update the details of the instructor. After updating any of these fields, click **Update Profile** to save your changes.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_rAMzd8phIe.cyrxaw.png)

You can update the following information about the instructor:

* **Instructor name**
  Enter or update the instructor’s full name.

* **Instructor photo**
  Upload or change the profile photo. This image will appear on course pages, instructor listings, and the website. Please upload a **high-quality square photo** to ensure proper display. Click **Change** to update the photo.

* **Email**
  Shows the instructor’s email address. To change this email, you will need to contact [support@codedamn.com](mailto:support@codedamn.com). This ensures account security and avoids accidental email changes.

* **Tagline**
  A short description or title for the instructor, e.g., “ReactJS Instructor.” This will appear on their public profile page and can help highlight expertise.

* **Long description**
  A detailed biography or overview of the instructor. This supports **Markdown**, so you can format text, add links, or lists to make the profile informative and engaging.

## Instructor permissions

To edit permissions for an instructor, please click on `Edit permissions` next to their instructor name.
![edit permissions](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_0KZ4Jb8hVw.kmpctj.png)

**Permission presets** on Fermion are designed to give you fine control over what each instructor can do within your school.

Add all of the required presets by clicking on them and providing confirmation. After you have added all the presets, click on **Save changes** to update the configuration.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_DGnDKNfhiN.bgxfpj.png)

By default, every new instructor is created with full (super admin) access to your school. However, you can customize each instructor’s permissions using granular preset options divided into three categories:

### Courses

You can allow an instructor to manage only specific courses, or grant them broader course administration rights:

<AccordionGroup>
  <Accordion title="Single course access">
    **Description:** Create and manage specific courses (You can select which courses you want to provide the access of).

    **What user can do:**

    * Create and manage selected course
    * Add and edit course content
    * Manage course coupons
    * View student lists
    * Delete course content

    **What user cannot do:**

    * Access other courses
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>

  <Accordion title="All courses administrator (no delete)">
    **Description:** Full course management access except any deletion permissions.

    **What user can do:**

    * Create and manage all courses
    * Add and edit course content
    * Manage course coupons
    * View student lists
    * Update course settings

    **What user cannot do:**

    * Delete courses or content
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>

  <Accordion title="All courses administrator">
    **Description:** Full course management access.

    **What user can do:**

    * Create and manage all courses
    * Add and edit course content
    * Manage course coupons
    * View student lists
    * Update course settings

    **What user cannot do:**

    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>
</AccordionGroup>

### Bundles

Control instructor access to bundle management features:

<AccordionGroup>
  <Accordion title="Bundle management">
    **Description:** Manage all bundles, including enrollment, coupons, pricing, and deletion.

    **What user can do:**

    * Create and manage all bundles
    * Enroll students to bundles
    * Create coupons for bundles
    * Update bundle pricing
    * Delete bundles

    **What user cannot do:**

    * Access courses or contests
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>
</AccordionGroup>

### Contest

Control instructor access to contest management features:

<AccordionGroup>
  <Accordion title="Single contest access">
    **Description:** Manage a specific contest (you will select which contest).

    **What user can do:**

    * Create and manage selected contest
    * Set contest prices
    * Manage contest coupons
    * Update contest details

    **What user cannot do:**

    * Access other contests
    * Manage any course content
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>

  <Accordion title="Single contest access [read only]">
    **Description:** Read-only access to specific contests (you will select which contest).

    **What user can do:**

    * Read results of contest
    * Export reports of contest
    * See enrolled students' performance in contests

    **What user cannot do:**

    * Update contest details
    * Access other contests
    * Manage course content
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>

  <Accordion title="Manage all contests">
    **Description:** Full management access to all contests and their internal data.

    **What user can do:**

    * Create and manage all contests
    * Set contest prices
    * Manage contest coupons
    * Update contest details

    **What user cannot do:**

    * Manage any course content
    * Access billing information
    * Manage webhooks
    * Access private API keys
  </Accordion>
</AccordionGroup>

### Miscellaneous

These settings cover access to other areas and advanced administrative features:

<AccordionGroup>
  <Accordion title="All live events administrator">
    **Description:** Full access to manage live events and sessions across all courses.

    **What user can do:**

    * Create and manage live events
    * Schedule live sessions (outside courses)
    * Manage live event settings
    * Control participant permissions

    **What user cannot do:**

    * Delete courses or content
    * Manage course content
    * Access billing information
    * Manage webhooks
  </Accordion>

  <Accordion title="Video library access">
    **Description:** Create and manage videos inside the video library.

    **What user can do:**

    * Upload videos
    * Update video metadata
    * Delete videos

    **What user cannot do:**

    * Access courses
    * Access billing information
    * Manage webhooks
    * Add/remove admins
  </Accordion>

  <Accordion title="Coding labs access">
    **Description:** Create and manage coding labs.

    **What user can do:**

    * Create new coding labs
    * Update existing coding labs
    * Delete coding labs

    **What user cannot do:**

    * Access courses
    * Access billing information
    * Manage webhooks
    * Add/remove admins
  </Accordion>

  <Accordion title="Billing access">
    **Description:** Read school transaction ledger data and payout information (Billing tab).

    **What user can do:**

    * View transaction history
    * Access payout information
    * View billing analytics

    **What user cannot do:**

    * Manage courses or content
    * Manage contests
    * Manage webhooks
    * Access private API keys
  </Accordion>

  <Accordion title="Developer access">
    **Description:** Manage webhooks and private API access.

    **What user can do:**

    * Manage webhooks
    * Access private API keys
    * View webhook event logs

    **What user cannot do:**

    * Manage courses or content
    * Manage contests
    * Access billing information
  </Accordion>

  <Accordion title="Read-only admin">
    **Description:** Manage everything on the platform as an admin, but in read-only mode.

    **What user can do:**

    * Manage webhooks
    * Access private API keys
    * View webhook event logs

    **What user cannot do:**

    * Delete courses
    * Delete contests
    * Remove other admins
  </Accordion>

  <Accordion title="Object storage access">
    **Description:** Manage object storage (upload/download/delete files).

    **What user can do:**

    * Upload new files on object storage
    * Delete files from object storage
    * Download files from object storage

    **What user cannot do:**

    * Manage courses or content
    * Manage contests
    * Access billing information
  </Accordion>

  <Accordion title="Community access">
    **Description:** Create and manage community channels and moderate discussions.

    **What user can do:**

    * Create community channels
    * Edit and archive channels
    * Add/remove channel participants
    * Moderate discussions and messages
    * Manage blacklisted users

    **What user cannot do:**

    * Access courses
    * Access billing information
    * Manage webhooks
    * Add/remove admin
  </Accordion>

  <Accordion title="User management access">
    **Description:** View all users, monitor course progress, and remove users from products.

    **What user can do:**

    * View all users in the school
    * View individual user course progress and activity
    * Remove users from courses and products
    * Reset user course progress

    **What user cannot do:**

    * Create or edit courses
    * Access billing information
    * Manage webhooks
    * Add/remove admin
  </Accordion>
</AccordionGroup>

Adjust these settings to provide the right level of access for each instructor. This helps you keep your school secure and ensures that instructors can only manage the areas they're responsible for.

## View instructor details

You can view detailed statistics and recent activity for each instructor to help monitor participation and performance.

To view these details, click the **View details** button or link next to any instructor in the Manage Instructor panel.

![Instructor Details Button](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_VyTt0iz8If.jirncf.png)

This will open a comprehensive summary page with the instructor's key activity metrics and a list of their recent live classes.

**The instructor details page includes:**

### Activity metrics

* **Live classes conducted**: The total number of live classes the instructor has hosted.
* **Hours taught**: The total live teaching hours.
* **Last active**: The most recent time the instructor was active (e.g., “2 hours ago”).

### Live classes

Below the activity metrics, you'll see a detailed table listing the instructor's most recent live classes. This table provides an overview of each session, including its title, scheduled and actual start times, end time, and total duration. Use this information to quickly understand the instructor's teaching activity and attendance patterns. Refer to the example image above for a preview of how this data is presented.

![Instructor Details Sample](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_ZXulU7B5vc.axkdvf.png)

These insights make it simple to monitor instructor engagement, track their teaching workload, and identify opportunities for recognition, support, or intervention. Use these details to help optimize your school's teaching resources and quality assurance.


# Payouts
Source: https://docs.fermion.app/manage-settings/manage-payouts

Understand how to configure payment methods, track earnings, and manage payouts efficiently on the platform.

Getting paid with Fermion is simple and hassle-free. Once your bank account is added in Payout Details, you can request a payout directly from your dashboard.

We like to think of payouts in two words: **easy and flexible**. You get paid how you want, when you want.

Fermion allows you to get payout whenever you need, so you can focus on teaching and creating content rather than worrying about payments.

Here’s how you can request a payout:

1. Go to **Billing & Earnings** in your instructor dashboard sidebar

![Billing and Earnings](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-10-2025/Billings%20and%20earning%20section.axxzzo.png)

2. Click on **Payout Details** and make sure your **bank account details** are added. Without this, your payout request cannot be processed.

![Add Payout Details](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-10-2025/Add%20Payout%20Details.aindre.png)

2. Go to **Billings & Earnings** → **Billing**
3. Click on **Request Bank Account Withdrawal**

![Request Withdrawal](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-10-2025/Request%20Withdrawal.ihwgqm.png)

Payouts are generally processed within **24 hours from Fermion’s end**, although your bank may take an additional 3–4 business days for the funds to appear in your account.

<Tip>
  You can track past payouts with the help of the **Transaction Ledger** in the same section.
</Tip>

If you ever face any issues or have questions, you can reach out to your Fermion relationship manager or email **[support@codedamn.com](mailto:support@codedamn.com)**. Fermion takes care of the payments so you can focus on what you do best.


# Manage Users
Source: https://docs.fermion.app/manage-settings/manage-users

View user profiles, manage enrollments, change account details, and enroll users in products.

You can manage all your school's users by navigating to **Instructor dashboard ⟶  Users ⟶  All users**.

![User profile default view](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_6LXLCrU0bO.fjleml.png)

This page lets you search and select any registered user via name, email and mobile number.

## What you can do on the user management page

For each user profile, you can:

* **View basic data**: See name, e-mail, join date, groups, and activity.
* **Actions** (For each user, you can):
  * Change the user's email address
  * Reset/change their password
  * Generate a one-time login link (so they can access their account instantly)
  * Delete the user and remove all their data

## Enrollments and Product Access

Clicking on the `Open detailed activity` button next to a user opens a detailed profile, as shown below.
![detailed activity](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_l3LRbUTnvW.mmbyzn.jpg)

Within the user's profile view, you'll see tabs for **Enrollments**, **Activity**, and **Exports**.

* The **Enrollments** tab shows all courses, bundles, events, or products that the user currently has access to.

To manually enroll a user in a product (such as a course, bundle, or digital product), simply select `Enroll in more products`, then choose the desired items. This allows you to give access even for users who joined via custom payments or special cases.

![enroll-manual](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_BR0lB7WVAb.dhpuxk.png)

* The **Activity** tab shows user activity such as:total time spent in the school, XP earned and Daily average minutes.

![User activity](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_QMdnOv6d91.avcxwm.png)

* The **Exports** tab lets you export all of this users' [Contest](/contests/introduction) submissions.

This page ensures you have full control over user accounts and enrollments, making it easy to update info, support users, and handle special cases.

If you need to adjust instructor privileges, see [Manage instructors](/manage-settings/manage-instructors).

## User actions

User Actions allow you to directly manage individual user accounts from the **All users** section in your dashboard. These actions help you make quick updates or administrative changes without navigating away from the page.

#### How to access user actions

<Steps>
  <Step title="Navigate to the All users section">
    Navigate to **Users** ⟶ **All users** section in your instructor dashboard sidebar.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_6LXLCrU0bO.fjleml.png)
  </Step>

  <Step title="Locate a user">
    Find the user whose details or credentials you want to modify.
  </Step>

  <Step title="Click the options menu">
    Click the **three dots (⋮)** button under the **Actions** column next to the user’s name.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_JplLMEBkyV.dvjchf.png)
  </Step>

  <Step title="Select an action">
    Choose the desired action from the dropdown menu.
  </Step>
</Steps>

#### What can you do with user actions?

From the **User Actions** menu, you can perform the following operations:

* **Modify email**: Update the user’s registered email address.
* **Modify password**: Reset or change the user’s account password.
* **Modify phone number**: Edit or update the user’s contact number.
* **Get login link**: Generate a one-time login link to access the user’s account (useful for troubleshooting or verification).
  <Warning> Handle this carefully since anyone with this link would be able to get access to user account. The link expires after first use.</Warning>
* **Delete user**: Permanently remove the user from your system.


# Partial payment dashboard
Source: https://docs.fermion.app/manage-settings/partial-payment-dashboard

Track and manage partial payment collections, monitor student installment plans, and view payment trends over time.

The Partial payment dashboard provides a comprehensive view of your installment payment collections. It helps you track students on payment plans, monitor collection trends, and identify overdue payments at a glance.

## Accessing the Partial payment dashboard

Follow these steps to access the Partial payment dashboard:

<Steps>
  <Step title="Open instructor dashboard">
    After logging in to your school, navigate to your **Instructor dashboard**.
  </Step>

  <Step title="Navigate to billing & earnings">
    In the sidebar menu, scroll down to the **Billing and earnings** section.
  </Step>

  <Step title="Click on earnings">
    Select **Earnings** to open your earnings dashboard.
  </Step>

  <Step title="Select Partial payments tab">
    Click on the **Partial payments** tab to view the partial payment dashboard.
  </Step>
</Steps>

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_Ks1oFoYmyT.mlnazz.png)

***

## Summary overview

The top section of the Partial payment dashboard displays key metrics and collection information:

### Total students

Shows the total number of students enrolled in partial payment plans, with a breakdown of their payment status:

* **Active**: Students with upcoming installments
* **Completed**: Students who have finished all their payments
* **Overdue**: Students with missed payment deadlines

Example: `9 total students: 5 active, 1 completed, 3 overdue`

### Collection in range

Displays the total amount collected within a selected date range. This helps you track revenue from partial payments over specific periods.

* **Amount**: The total collection amount (e.g., `₹31,175`)
* **Date range**: The period for which collections are calculated (e.g., `Nov 4 - Dec 4, 2025`)

### Chart date range

Allows you to select a custom date range for viewing collection trends. Use the calendar icon to adjust the period shown in the Collections Overview chart.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_YafJoYnGNr.idsxmv.png)

***

## Collections overview chart

The Collections overview chart provides a visual representation of your partial payment collections over time.

**Purpose**: Track partial payment collections over time

The chart displays:

* **Y-axis (Amount Collected)**: Shows the collection amount, typically ranging from ₹0 to ₹10,000 with increments
* **X-axis (Date)**: Displays the timeline with date labels
* **Line Graph**: A green line with shaded area below showing the amount collected on each date

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_j4M6IiXmXO.mfelho.png)

***

## Partial payment students table

The Partial payment students table provides detailed information about each student enrolled in an installment payment plan.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/04-12-2025/Arc_Rk1ovzsfuL.mkgmve.png)

### Table Columns

| Column               | Description                                                                     |
| -------------------- | ------------------------------------------------------------------------------- |
| **Student**          | The name and profile of the student enrolled in the payment plan                |
| **Product**          | The course, bundle, or digital product purchased through installments           |
| **Progress**         | Shows the payment progress (e.g., "1 of 3 payments") with a visual progress bar |
| **Next Installment** | The amount and due date of the next payment (e.g., "₹5,000 Due Oct 15, 2025")   |
| **Status**           | Current payment status: **Active**, **Overdue**, or **Completed**               |

### Payment status types

* **Active** (Blue badge): Student has upcoming installments that are not yet due
* **Overdue** (Red badge): Student has missed a payment deadline
* **Completed** (Green badge): Student has successfully completed all installments

<Warning>
  Students with **Overdue** status require immediate attention. Consider sending payment reminders or reaching out to help them complete their payments.
</Warning>

### Understanding progress

The progress indicator shows:

* **Current payment number**: Which installment the student is on (e.g., "1 of 3")
* **Visual progress bar**: A blue bar that fills based on completion percentage
* **Total installments**: The total number of payments in the plan


# Password Protection
Source: https://docs.fermion.app/manage-settings/password-protect

Learn how to enable password protection for your website to restrict access

Password protection allows you to temporarily restrict access to your site by setting a global password. Users must enter this password before viewing your site or logging in.

***

## Enable Password Protection

You can enable password protection from the **Security** section in **School Settings**.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-11-2025/screenshot-000620@2x.degawa.png)

This will temporarily restrict access to your site by setting a global password. Users must enter this password before viewing your site or logging in.

This feature is ideal for:

* Pre-launch or private institutions
* Testing environments
* Exclusive cohorts or invite-only batches

Once password is set, whenever someone opens your website it would look like this:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-11-2025/screenshot-000621@2x.mlwfev.png)

## How to embed password-protected website inside another app externally?

You might want to password protect your website and embed it externally in a different app.

To do that, you must set a JWT as a cookie named `website-password`. For example, let us assume your website is `lms.example.com` which uses Fermion. In order to securely access it from an external app, do the following:

* Enable password on the website (assume you set password to be `123456`)
* Make a secure HTTPS request to `request-password-enabled-website-access` API endpoint to get a unique embed cookie. This will return you a string that you must use as a cookie. Learn more about calling this API here: [https://docs.fermion.app/api-reference/misc/request-password-enabled-website-access](https://docs.fermion.app/api-reference/misc/request-password-enabled-website-access)
* Embed the website in a webview/iframe in your external app
* Set the cookie `website-password` to have the value of the JWT returned by the API above.

This will make it possible for you to embed your website externally, while making it inaccessible to general public via regular web browsers.


# Analytics
Source: https://docs.fermion.app/manage-settings/school-analytics

View student activity, usage insights, and performance metrics for your Fermion-powered school.

Fermion’s **Analytics** provides a unified view of how your school performs:  tracking bandwidth, storage, engagement, and activity across the platform.\
These insights help you optimize learning experiences, monitor system usage, and understand your audience better.

![Analytics overview](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_Lzem18SyFN.vblbss.png)

***

## Accessing analytics

<Steps>
  <Step title="Open your instructor dashboard">
    Head to your **Instructor Dashboard** after logging into your Fermion school.
  </Step>

  <Step title="Navigate to analytics">
    In the sidebar, click on **Analytics** to open the analytics dashboard and view performance metrics.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/hS9oexgAhJ.vqpdqd.png)
  </Step>

  <Step title="Explore metrics">
    Use the **date filter** to explore real-time data such as bandwidth, storage, traffic, [email](/marketing-tools/email-marketing) performance, and engagement.
  </Step>
</Steps>

## Platform overview

The **Platform analytics** section provides a snapshot of your school’s performance and infrastructure usage. You can filter analytics by date range using the date selector on the top right.

<iframe title="YouTube video player" />

<Columns>
  <Card title="Bandwidth consumed">
    Shows total **bandwidth** used by your school for all hosted content - including [video](/recorded-videos/introduction), labs, and API calls. This metric is used for **bandwidth overage billing**.
  </Card>

  <Card title="Storage used">
    Displays total **storage space** occupied by your uploaded files, videos, and resources. Exceeding your plan’s quota may lead to **storage overages**.
  </Card>
</Columns>

<Columns>
  <Card title="Page views & visitors">
    View total **page-views** and unique **visitors** over the selected time range. This helps you understand how new and distinct learners interact with your content.
  </Card>

  <Card title="Coding & DSA labs" href="/creating-io-coding-labs/introduction">
    Monitor **[coding lab activity](/creating-coding-labs/what-are-coding-labs)** (hours spent) and [DSA lab](/creating-io-coding-labs/introduction) runs (executions). Useful for tracking student engagement and lab infrastructure usage for your entire school.
  </Card>
</Columns>

<Columns>
  <Card title="Email analytics" href="/marketing-tools/email-marketing">
    Track all outgoing communication from your school through [email](/marketing-tools/email-marketing), including:

    * **Emails sent:** Total number of emails dispatched.
    * **Emails bounced:** Emails that failed to deliver.
    * **Marked as spam:** Emails flagged by users or email providers as spam.
    * **Unsubscribed users:** Number of users who opted out of future emails.
  </Card>

  <Card title="DRM licenses" href="/live-classes/drm-and-watermarking">
    Monitor the number of **[Digital Rights Management (DRM)](/live-classes/drm-and-watermarking)** licenses utilized across your hosted video content.Each DRM license corresponds to a secured video playback instance.
  </Card>
</Columns>

![Platform analytics graph](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_Fa0HLNCq2J.uwkkkd.png)

***

## Engagement & traffic insights

The lower section of the analytics page shows detailed engagement and audience insights.\
These metrics help you identify where users come from, what pages they visit most, and what devices or browsers they use.

![Engagement metrics](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_s4Oc0l250M.gucgis.png)

<Columns>
  <Card title="Top Referrers">
    Lists the top external sources that drive visitors to your school (e.g., social media, partner websites, or search engines).
  </Card>

  <Card title="Top Pages">
    Displays your most visited pages and routes (such as `/join-call`, `/course-item`, or `/dashboard`). This helps to identify your most popular pages across school.
  </Card>
</Columns>

<Columns>
  <Card title="Operating systems & browsers">
    Shows what **devices (Operating System) and browsers** your users are accessing the platform from.
  </Card>

  <Card title="Geographic insights">
    View where your users are located, including **countries**, to understand your global reach.
  </Card>
</Columns>

<Check>
  Your **Analytics Dashboard** is the single source of truth for how Fermion bills you for **usage and overages**. Metrics like **bandwidth consumed**, **storage used**, and **DRM licenses** directly influence your monthly billing.

  Fermion’s pricing is **transparent and usage-based**, ensuring you only pay for what you actually consume. Head over to the [Fermion Pricing](https://fermion.app/pricing) page to learn more about plan limits and overage calculations.
</Check>

***

## Access analytics via API

You can also access your analytics programmatically through Fermion’s API.  Head over to our [API documentation](/api-guide/introduction) to learn more.

The following API endpoints are available to access user and school analytics over API:

#### Sales Data

* **Get sales data with filtering**: `POST`

#### User Progress

* **Get user bundle progress for all bundles**: `POST`
* **Get all courses progress of a given user**: `POST`
* **Get user bundle progress for specific bundle**: `POST`
* **Get individual user course progress**: `POST`

<Note> All requests require authentication using the `FERMION-API-KEY` header.</Note>

These endpoints let you programmatically retrieve progress, completion, and sales analytics to integrate with your dashboards or reporting tools.

## Next steps

<Columns>
  <Card title="Manage Instructors" href="/manage-settings/manage-instructors">
    Learn how to add, remove, and assign roles to instructors within your school.\
    [Read instructor management guide](/manage-settings/manage-instructors)
  </Card>

  <Card title="Manage Users" href="/manage-settings/manage-users">
    Understand how to view and control user access in your school.\
    [View user management guide](/manage-settings/manage-users)
  </Card>
</Columns>


# School Event Logs
Source: https://docs.fermion.app/manage-settings/school-event-logs

Monitor and track all events and actions performed in your school, including deletions, updates, and other administrative activities.

The **School Event Logs** dashboard provides a comprehensive audit trail of all events and actions performed within your school. You can track who performed what action, when it occurred, and on which resource. This helps maintain accountability, troubleshoot issues, and ensure transparency across your school's operations.

***

## Accessing School Event Logs

To view the **School Event Logs** dashboard:

<Steps>
  <Step title="Open instructor dashboard">
    Log in to your instructor account and navigate to your **Dashboard**.
  </Step>

  <Step title="Go to Settings">
    In the sidebar, click **Settings** to expand the available configuration options.
  </Step>

  <Step title="Select School event logs">
    Click **School Settings** → **School event logs** to open the event logs dashboard.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_91v7M8cNxk.jypvdu.png)
  </Step>
</Steps>

***

## Understanding the Event Logs Dashboard

The **School Event Logs** dashboard displays a comprehensive table of all events that have occurred in your school. Each log entry includes detailed information about the action, the resource affected, and who performed it.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_88QSazMNzB.bilbqt.png)

### Event Log Columns

The dashboard displays the following information for each event:

* **Timestamp**: The date and time when the event occurred. You can filter logs by timestamp using the filter icon in the column header.
* **Action**: The specific action that was performed (e.g., "Deleted", "Updated", "Created").
* **Resource Type**: The type of resource that was affected by the action (e.g., "Course Item", "Digital Product", "Video", "Live Event Session", "Payment Gateway").
* **Resource ID**: A unique identifier for the specific resource that was acted upon.
* **Actor Type**: The role of the user who performed the action (e.g., "Instructor", "User", "API").
* **Actor User ID**: The unique identifier of the user who performed the action.
* **Technical Details**: A "View Details" button that provides additional technical information about the event.

***

## Filtering Event Logs

You can filter the event logs using two main filters to narrow down the results:

### Resource Type Filter

The **Resource Type** filter allows you to view events for specific types of resources:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_vfjzRyJaOp.sfylez.png)

Available resource types include:

* **All Resources**: Shows events for all resource types (default)
* **Course Item**: Events related to course items
* **Live Event Session**: Events related to live class sessions
* **Digital Product**: Events related to digital products
* **Video**: Events related to videos
* **Payment Gateway**: Events related to payment gateways

### Actor Type Filter

The **Actor Type** filter allows you to view events performed by specific types of users:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_GfFMYSvxuC.zrqjwf.png)

Available actor types include:

* **All Actors**: Shows events from all actor types (default)
* **User**: Events performed by regular users/students
* **Instructor**: Events performed by instructors
* **API**: Events performed through API calls

***

## Viewing Technical Details

For any event log entry, click the **View Details** button to access in-depth technical information about that specific event. The technical details panel displays:

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_AhZSR08dHX.eolumf.png)

Here you'll find:

* **IP Address**: The IP address from which the action was performed (masked in UI for privacy).
* **User Agent**: Detailed information about the browser and device used to perform the action.

This information can help with advanced troubleshooting, auditing, and investigating the context of specific actions—such as identifying suspicious activity or confirming how and from where an event was triggered.

## Why Event Logs Are Important

School event logs provide instructors with complete visibility into all activities within their school. This helps:

* **Accountability**: Track who performed what action and when
* **Troubleshooting**: Identify issues by reviewing event history
* **Security**: Monitor for suspicious or unauthorized activities
* **Compliance**: Maintain an audit trail for regulatory requirements
* **Transparency**: Ensure all actions are logged and traceable

***

## Next Steps

<Columns>
  <Card title="User Access Log" href="/manage-settings/user-access-logs">
    Monitor all logged-in sessions and maintain account security.
  </Card>

  <Card title="School Analytics" href="/manage-settings/school-analytics">
    Gain insights into your school's analytics and track feature usage.
  </Card>
</Columns>


# Login, Security and Support
Source: https://docs.fermion.app/manage-settings/security-settings

Manage login, security, and support configurations for your school

The **School Settings** page lets administrators control how users log in, how secure sessions are managed, and which contact information is shown for support. These settings help maintain a secure experience across your school, both for the instructor and student.

***

## Login Options

Manage which authentication methods are available for your users.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_LCSmGTIcpY.bjtwrl.png)

### Available methods

* **Google login**: Allow users to sign in with their Google accounts.
* **Email/Password**: Standard authentication via email and password.
* **Phone number (OTP)**: Let users log in with a one-time password sent to their phone.

Administrators can enable one or more methods depending on their school’s accessibility and security needs.

<Note>
  At least **one login method** must remain enabled for users to access their accounts. Enabling
  multiple methods can improve accessibility and convenience for your learners.
</Note>

***

## Security

Control security behavior for your school, including session restrictions, logout behavior, and [video watermarking](/live-classes/drm-and-watermarking#video-watermarking).

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_Amb6ulzrA5.duupae.png)

### Device login limit

Limit the number of devices a user can stay logged in on simultaneously.

* **Maximum device login limit**: Set how many active devices a single user can have at once. If this limit is exceeded, the user will be will be prompted to log out from already logged in devices through the session manager screen.

<Note>
  If your users commonly access your school on both mobile and desktop, we recommend setting this
  value to at least **two devices**.
</Note>

***

### Session and Access Controls

Manage how users interact with sessions and password-protected sites.

* **Disable user logout**: Prevents users from logging out on their own. This can be useful in controlled environments.

<Check>
  If this option is enabled, you must manually log out users through the **User Access Logs**
  section. See [User Access Logs](/manage-settings/user-access-logs) for details.
</Check>

* **Enable password protection for your website**: Temporarily restrict access to your site by setting a global password. See [Password Protection](/manage-settings/password-protect) for details.

***

### Video Watermarking

Overlay user identifiers during video playback to prevent content misuse and identify unauthorized sharing.

**Watermark configuration:**

* **Font size (px)**: Adjust text size for readability.
* **Opacity (%)**: Control how transparent the watermark appears.
* **Display options**: Choose which identifiers to show:
  * Name
  * Email
  * Phone number
  * User ID

Multiple identifiers can be combined in a single watermark for enhanced traceability.

<Example>
  ![Watermark
  preview](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/video-watermark.mqethn.png)
</Example>

Learn more about [Video Watermarking](/live-classes/drm-and-watermarking#video-watermarking).

***

## Support Email

Specify the contact email address displayed to users for help or technical assistance.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/21-10-2025/chrome_HO1afE7ghR.hvsgmh.png)

### Configure your support email

* **Support email address**: Displayed in user help pages and in automated communication (e.g., password resets or notifications).
* Click **Save changes** after updating your address to apply changes across your school.

You can also **preview the user help page** to see how this contact information is displayed to learners.

<Note>
  If a support email is not configured, all user support requests are automatically redirected to
  your **billing email** by default.
</Note>

***

## Best Practices

* Always enable at least one **secure authentication method** (Google or Email/Password).
* Use **device limits** and **session controls** to prevent account sharing.
* Configure **video watermarking** for courses containing proprietary or paid video content.
* Maintain an up-to-date **support email** to ensure your learners can reach you easily.

***


# User Access Log
Source: https://docs.fermion.app/manage-settings/user-access-logs

Monitor all logged-in sessions in your school, view detailed session information, and maintain account security.

The **User Access Log** feature allows instructors to monitor all active and past sessions in their school. You can see when users have logged in, their device details, IP addresses, and other session-specific information. Monitoring user sessions helps ensure account security, detect unauthorized access, and maintain oversight of student activity.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/ClGPK62oYB.glbvdc.png)

## Why user access logs are important

User access logs provide instructors with complete visibility into all user sessions, including login times, IP addresses, and device details. This not only helps identify suspicious activity and troubleshoot login issues but also ensures that the real user is accessing the platform, preventing account sharing or impersonation. This contributes to maintaining a secure and trustworthy learning environment for all students.

<Note>
  If you have enabled a **[maximum device login limit](/manage-settings/change-school-settings#security)** of more than two, users will be able to login with the help of multiple devices and all of those sessions will be logged in this section.
</Note>

## How to view user access log

<Steps>
  <Step title="Open instructor dashboard">
    Navigate to your **Instructor Dashboard**. In the sidebar, click **Settings** → **User access log**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/chrome_lB8GyOxnfo.ldhahd.png)
  </Step>

  <Step title="View user access log">
    This will display a table with all active and past sessions, including:

    * **Login Time**: When the user logged into your school
    * **User**: The name and email of the user
    * **IP Address**: IP Address of the device used to log-in to your school
    * **User Agent**: Details of the browser and device OS used to log-in to your school
    * **Logout Action**:  Instructors can logout a particular session/user from this dashboard.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/20-10-2025/ClGPK62oYB.glbvdc.png)
  </Step>

  <Step title="View detailed IP information">
    To see more information about a particular user, click the **ℹ (info) button** next to their IP Address.

    <Accordion title="Get IP information">
      The detailed information about the user's IP Address includes:

      * **IP Address**
      * **Country**
      * **Region**
      * **City**
      * **ZIP Code**
      * **Timezone**
      * **Coordinates**
      * **ISP**
      * **Organization (of ISP)**
      * **AS (Autonomous System) Number**
    </Accordion>
  </Step>
</Steps>

This allows instructors to track all the logged in sessions, log out suspicious sessions immediately and maintain a secure learning environment for all users.

## Next steps

<Columns>
  <Card title="Manage Features" href="/manage-settings/manage-features">
    Control the features available to your instructors and students in your school.
  </Card>

  <Card title="School Analytics" href="/manage-settings/school-analytics">
    Gain insights into your school’s analytics and track feature usage.
  </Card>
</Columns>


# Account Settings
Source: https://docs.fermion.app/manage-settings/user-settings

Learn how to manage your instructor account settings, including profile information, email, tagline, long description, and password.

Your instructor account settings allow you to manage how you appear across your courses and on your website. Keeping your profile up-to-date helps students recognize you easily and builds credibility. In this section, you can update your name, profile photo, tagline, long description, and email. Each change ensures that your presence is consistent and professional throughout the platform.

## Access account settings

You can access the account settings with the help of the following steps:

<Steps>
  <Step title="Access account settings">
    To start updating your account, go to your **Instructor Dashboard** sidebar and click **Settings → Account Settings**. This will open your account management page where all editable fields are displayed.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_6LMV3GHeFQ.izmxbv.png)
  </Step>

  <Step title="Update profile photo and name">
    Your **display name** and **profile photo** are key elements of your identity on the platform.

    * **Your Name:** Update the name that will appear on your course pages and website. Use your full name or the name you prefer students to see.
    * **Profile Photo:** Click **Change** to upload a high-quality square photo. This photo will appear on all your course pages and is important for recognition and branding.
  </Step>

  <Step title="Update tagline and long description">
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/bL6HEp8iFd.nkxlvh.png)
    Your **tagline** and **long description** help students understand who you are and what you teach.

    * **Tagline:** Add a short, descriptive tagline that summarizes your teaching style or expertise. This will appear on your website.
    * **Long Description:** Provide a detailed description of yourself, your experience, and the courses you teach. You can format this text using Markdown for better readability.
  </Step>

  <Step title="Update email">
    Your email is crucial for notifications and account security. To ensure your email address is correctly updated, you will need assistance from our support team.

    * To change your email, contact **[support@codedamn.com](mailto:support@codedamn.com)**.
  </Step>
</Steps>

## Update password

Passwords protect your account and all associated course content. Updating your password regularly is a good security practice, especially if you suspect your account credentials may be compromised. This section allows you to securely set a new password while keeping your account protected.

<Steps>
  <Step title="Access password settings">
    Scroll down to the **Update password** section within **Account Settings**. This is separate from your profile information to emphasize security.
  </Step>

  <Step title="Set a new password">
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_afFnMbUELi.fuofea.png)

    * Enter your **New password** in the first field.
    * Confirm your new password in the **Confirm new password** field to avoid typing errors.
  </Step>

  <Step title="Save changes">
    After entering your new password, click **Update password** to apply the changes. Make sure your new password is strong and not used elsewhere for better security.
  </Step>
</Steps>

Now your account details are updated across your school!


# Affiliate System
Source: https://docs.fermion.app/marketing-tools/affiliate-marketing

Learn how to set up and manage your affiliate program, track referrals, and reward partners for driving course enrollments.

Fermion allows you to configure a powerful affiliate marketing system for your online academy, with its built-in affiliate marketing tooling. With Fermion, you can:

* Have custom tracking systems

* Automate everything

* Create custom affiliate links.

* Monitor your affiliates and optimize in real-time

*(If you'd like to read more about what is affiliate marketing, [you can check this out.](https://en.wikipedia.org/wiki/Affiliate_marketing))*

***

In this section, we'll discuss 5 things:

* How you can enable and setup affiliate program for your online academy
* How your affiliate system looks like for your users
* What are the general terms of the affiliate program for users
* Additional affiliate tooling for your academy
* How affiliate payouts work

## Setting up affiliate marketing

Fermion offers you a built-in affiliate system without letting you spend a minute building anything. You can leverage this tooling to get started quickly and save time that you may have otherwise spent building a custom affiliate program.

Setting up affiliate marketing system on Fermion is a simple process:

<Steps>
  <Step title="Enable affiliate marketing">
    Affiliate System for your online school is `DISABLED` by default. Head over to the `Marketing` section in the `Manage Features` section from your Fermion dashboard, to enable affiliate marketing and setup your program. Learn more about [manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Access affiliate marketing">
    Head over to **Marketing Tools → Affiliate marketing** to access affiliate marketing tools and configuration.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/m0aWp5Twja.ankfmb.png)
  </Step>

  <Step title="Configure your affiliate marketing parameters">
    The `Affiliate settings` is the area from where you can manage your affiliate marketing program data.

    ![step9](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_3eepad0bwa.hfpifa.png)

    You can switch the program status:

    * Clicking on `disable program` will completely disable the program. This means that if you have any existing affiliate links, they will stop working.
    * Clicking on `unlisted program` will partialy disable the program. You would not be able to create any new links but the existing affiliate links will keep working as expected.
    * Clicking on `public program` means that your program is public for your users.

    You can customise a default percentage commission from this area. This means that all the users by default will be eligible for this percentage commission.
  </Step>
</Steps>

#### Enable unenrolled users to create published products link

When this toggle is enabled, users who are **not enrolled** in your published courses or products will still be able to create and share affiliate links for those items. This allows broader promotion of your courses and can help expand your affiliate network.

#### Enable unenrolled users to create unlisted products link

This option allows users who **aren’t enrolled** in your unlisted digital products to create affiliate links for those items. Enabling this can help you reach more potential affiliates, but keep in mind that it may expose your unlisted courses or products to a wider audience than intended.

<Tip>
  Consider using this toggle only for select campaigns where broader promotion is acceptable, as it may reveal unlisted content to more people.
</Tip>

Make sure to click on `Save changes` to save the settings you have configured.

Once you click on `Public program` and `Save changes` your affiliate program will be live for your users!

## How your affiliate system looks like for your users

Every user will be able to see an option - `Refer and earn money` inside their course dashboard once your affiliate program is public. This is how it will look like:

![stepxs](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/13-11-2024/08%402x.pxzwmp.png)

Once they click here, they will be redirected to their `Affiliate dashboard`. This is how their affiliate dashboard will look like:

![stepyx](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/13-11-2024/01%402x.fvuyzr.png)

* The user affiliate dashboard shows data for all the courses and sale which they are an affiliate partner of.
* Every product has an associated affiliate link which is unique to every user.
* Additionally, with every product and affiliate link, data such as: the comission %, amount earned, new sales, valid sales, and refunded sales are also visible (refer image below).
* The data is updated in real-time.

![stepdd](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/13-11-2024/52%402x.eejedx.png)

For detailed information about the affiliate payout dashboard, including how to request payouts and manage bank account details, see [Affiliate Payout Dashboard](/marketing-tools/affiliate-payout-dashboard).

## Affiliate terms of service for users

Below are the terms of service we notify to every user who is a part of the affiliate program under your school on Fermion:

1. When a user shares their affiliate link with someone and they purchase, it will add as to "New sale" in your dashboard.

2. Once 15 days have passed, the new sale becomes `verified sale`.

3. At any point, if the sale is refunded for some reason, it'll move to `Refunded sales` section.

4. Minimum balance to withdraw is ₹1000 if the user is based out of India, or \$150 (or equivalent) if the user is based outside of India.

5. User's affiliate payout will only be done via bank transfer and no other means.

6. If a user is based outside of India, there would be additional SWIFT bank transfer charges applicable.

7. Payouts will be done at most once every month.

8. Affiliate commission will be rewarded for one-time sales for now.

9. In case any user needs more help, they can contact their website administrator (you).

## Additional affiliate tooling for your academy

#### Monitor your affiliate sales

There are various functionalities available for your school inside the Affiliate Program. Click on `Sales dashboard` inside the `Affiliate Marketing` tab.

The `Affiliate sales dashboard` is the area where you can view and monitor your recent affiliate sales. It shows the name of the affiliate user, the product name of the sale they helped you make, the commission they earned as well as the date of the sale.

![step2](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/13-11-2024/58%402x.cljpkc.png)

#### Create custom affiliate links

Head over to `Create custom link` section, from the left sidebar.

![step3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_qh3VjusW0x.hpjjvb.png)

This is the area from where you can create and set up custom affiliate links for your users. For example: if you are partnering up with a student influencer who would also like to market your course to drive additional earnings for you as well as themselves, you can create a custom affiliate link with a lowered commission rate for that user (different from other users).

On the screen, you will see all the courses and digital products you have created inside your school. Click on any course, for which you would like to create a custom link for. For example: I have created a bunch of demo courses (shown in the below image) inside my school, and selected a course to create a custom link for.

![step4](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_FoIFkqrlxr.mecbii.png)

Once you have selected your product, scroll to the bottom of the page where you can search a specific user by their email. Simply enter the email and click on `Search for users`, once you find the user, click on their name.

![step5](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_V4CuVOw6ea.ycukxu.png)

Once you click on the user's name, enter the percentage commission rate for the user and click on `Create Affiliate Link`

You will see the below modal, once your link is successfully created. This link will be visible to you as well as the user inside their affiliate dashboards.

![step7](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/13-11-2024/08%402x.wzbllo.png)

Voila! You just learnt how to create custom links for your platform! 🎉

#### Monitor all custom links

Head over to `List all custom links` tab from the left sidebar. This is the area which lists down all the custom affiliate links you have created so you can view and monitor them at one glance.

![step8](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_kGDusmBy2H.zsbewk.png)

## How affiliate payouts work

* Fermion manages and dispatches payouts to all affiliates who are a part of your school minimising your hassle to manually calculate and share payments.

* Minimum balance for the user to withdraw their payments is ₹1000 if they're based out of India, or \$150 (or equivalent) if they're based outside of India.

* All affiliate payouts will be done via bank transfers.

* If affiliates are based outside of India, there would be additional SWIFT bank transfer charges applicable.

* All affiliates would be able to add their payment information to receive payouts, from inside their user affiliate dashboard. For step-by-step instructions on using the payout dashboard, see [Affiliate Payout Dashboard](/marketing-tools/affiliate-payout-dashboard).

* Fermion charges 1% fee on every affiliate sale to process the sale for you. For example: if your school is under the basic (free plan) and you have set a 10% commission for your affiliates, here's how the payout structure would look like for you:

  * Affiliate commission: 10%
  * Fermion commission : 10%
  * Fermion affiliate fee: 1%

* The invoices for affiliates will also be accounted for by Fermion.


# Affiliate Payout Dashboard
Source: https://docs.fermion.app/marketing-tools/affiliate-payout-dashboard

Learn how to view your affiliate earnings, request payouts, and manage your affiliate commission from the dedicated payout dashboard.

Users can see their accumulated affiliate commission amount in a dedicated dashboard from which they can request payouts directly to their bank account.

<Steps>
  <Step title="Access Affiliate Dashboard">
    From your user dashboard, click on **Affiliate dashboard** to access your affiliate payout dashboard.

    ![Access affiliate dashboard](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_rz7RbL7K25.rhniue.png)
  </Step>

  <Step title="View Dashboard Sections">
    You will see a dashboard with the following sections:

    **Earnings Section:**

    * Shows total **Eligible Earnings** - the amount you can withdraw
    * Shows total **Unsettled Sales** - sales that are still in the waiting period

    **Bank Account Section:**

    * If not configured, users are prompted to add their account details
    * Users cannot request payouts without adding bank account details first

    ![Dashboard with earnings and bank account](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_UXbg9SGG9X.okxgkm.png)
  </Step>

  <Step title="Configure Bank Account">
    Once bank account details are added and users have some eligible amount, the same will be shown up on the dashboard:

    * **Bank account configured** status is displayed with account type (e.g., Indian Account)
    * Masked bank account details are shown (Name, Email, Account number, IFSC, PAN)
    * **Request Payout** button becomes available when you have eligible earnings

    ![Configured bank account and payout button](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Slack_9MQM769gss.wpsctw.png)
  </Step>

  <Step title="View Payout Request History">
    Once a user requests payout, the request is shown with a new section called **Payout Request History**:

    The payout history table displays:

    * **Date**: When the payout was requested
    * **Gross Amount**: Total commission amount before deductions
    * **TDS**: Tax Deducted at Source (if applicable)
    * **Net Payout**: Final amount after TDS deduction
    * **Status**: Current status of the payout (e.g., Processing, Completed)
    * **Actions**: Options to view details or hide the earnings breakdown

    You can expand each payout request to view the **Earnings Breakdown**, which shows:

    * **Product**: Name of the course/product
    * **Sale Date**: When the sale occurred
    * **Commission**: Individual commission amount for each sale

    ![Payout request history with earnings breakdown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Slack_zZsMBRbOMU.lrekaq.png)
  </Step>
</Steps>

## Understanding Your Sales Data

The dashboard includes an accordion section that explains different sales statuses:

* **New sales**: Sales that have just happened and will remain in this status for about 15 days. After 15 days, if not refunded, they become valid sales.

* **Valid sales**: Sales that have passed the 15-day waiting period and are confirmed. These can be withdrawn as part of your affiliate earnings.

* **Refunded sales**: Sales that have been refunded by customers. These do not count towards your affiliate earnings and cannot be withdrawn.

## Affiliate Links Section

The **Affiliate Links** section shows links of all the courses/products that you are eligible to generate affiliate links for. Each product has:

* A unique affiliate link that you can share
* Commission percentage for that product
* Real-time sales data (new, valid, and refunded sales)
  ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_u6VpegD0BI.jupecl.png)

## Products to Show Affiliate Links For

If enabled by the instructor, the **Products to show affiliate links for** section allows you to generate affiliate links for products you are not enrolled in. This feature expands your ability to promote and earn commissions from a wider range of courses and digital products.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_Ag02w40NLg.fmzlyv.png)

## Requesting a Payout

To request a payout:

1. Ensure your bank account is configured with all required details
2. Verify that you have eligible earnings (minimum ₹1000 for Indian accounts or \$150 for international accounts)
3. Click the **Request Payout** button
4. Your payout request will be processed and appear in the Payout Request History

<Warning>
  Payouts are processed at most once per month. Make sure you have the minimum required balance before requesting a payout. If you're based outside of India, additional SWIFT bank transfer charges may apply.
</Warning>

For more information about affiliate marketing setup and configuration, see [Affiliate System](/marketing-tools/affiliate-marketing).


# UTM Campaign Reports
Source: https://docs.fermion.app/marketing-tools/analytics-funnel-builder

Learn how to generate detailed reports for your UTM campaigns to track conversion funnels and purchase events.

The **Analytics Funnel Builder** allows you to generate detailed reports for your UTM campaigns, helping you track user conversions, purchase events, and overall campaign effectiveness.

**UTM (Urchin Tracking Module)** parameters are tags added to the end of a URL that allow you to track the source, medium, and campaign name for every visitor coming to your site. By analyzing UTM data, you can see which marketing channels (like **Google Ads, Facebook, or email newsletters**) are driving traffic, which campaigns are performing best, and how users move through your conversion funnel. This granular insight helps you understand user behavior, attribute conversions accurately, and optimize your marketing strategies to maximize ROI.

Learn more about [UTM parameters](https://en.wikipedia.org/wiki/UTM_parameters).

<Tip> Using UTM parameters consistently across campaigns ensures reliable tracking, making it easier to compare performance between sources and campaigns. </Tip>

## Accessing the analytics funnel builder

Follow these steps to open the Analytics Funnel Builder in your instructor dashboard:

<Steps>
  <Step title="Ensure analytics funnel builder feature is enabled">
    Make sure the **Analytics Funnel Builder** is enabled in the **Marketing** section of **Manage Features**.  Learn more by referring to the [Manage Features documentation](/manage-settings/manage-features).
  </Step>

  <Step title="Go to marketing tools">
    In your **instructor dashboard sidebar**, click on **Marketing Tools**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_3z6wa09VbD.mvqbqu.png)
  </Step>

  <Step title="Open Analytics funnel builder">
    Within Marketing Tools, click on **Analytics funnel builder** to access your UTM campaign reporting features.
  </Step>
</Steps>

## Report configuration

Before generating a UTM campaign report, you need to configure several key parameters.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_I2UoNFa9NK.lnzxfu.png)

**Date range:** Choose the period for your analysis. This could be a week, a month, or a custom range, depending on your campaign goals. Setting the correct date range ensures your report focuses on the timeframe relevant to your campaign performance.

**UTM source:** Enter the UTM source you want to analyze, such as `google`, `facebook`, or `newsletter`. This allows you to segment traffic by source and understand which platforms are driving the most conversions.

**Follow-on event:** Select the type of conversion event you want to track for users coming from your UTM campaign. This measures the effectiveness of your marketing efforts by showing which visitors actually converted. Available follow-on events include:

* **Any purchase:** Tracks all purchase events, including [course](/setting-up-course/prerequisites) purchases,  and other [digital product](/digital-products/introduction) sales.

**Consider same IP as same user:** Enable this option to match users by their IP address. This helps link multiple sessions and interactions to a single user, improving data accuracy. This is especially useful when users switch devices or sessions during the purchase journey.

<Tip>
  Enabling IP matching can help reduce duplicate counts and provide a clearer picture of actual conversions.
</Tip>

***

## Generating your report

Once your parameters are configured, review your selections for date range, UTM source, follow-on event, and IP matching. Click **Generate report** to produce detailed analytics showing conversion funnels, purchase events, and key metrics from your UTM campaigns.

<Info>
  Suppose you ran a Facebook ad campaign promoting a new course. By selecting a 30-day date range, `facebook` as the UTM source, and **Any Purchase** as the follow-on event while enabling IP matching, you can track exactly how many visitors from Facebook ended up purchasing. This allows you to evaluate ROI and optimize future campaigns.
</Info>


# Email Sender Configuration
Source: https://docs.fermion.app/marketing-tools/email-automation

Automate your email campaigns to engage learners and keep your students informed.

Fermion provides an end-to-end ecosystem for all of your marketing tools, this includes various email automation flow like:

1. A payment confirmation email is sent to users immediately after they make the purchase to your course.
2. An email is dispatched, along with course access, whenever someone purchases your course.
3. An email is dispatch one day, as well as 30mins prior to your live classes.

These are just three of the many email flows that are already linked to your account. We ensure maximum student participation inside your course, via these email flows.

If you have a specific email flow in your mind, useful for your use-case, feel free to share with us by reaching us at [support@codedamn.com](mailto:support@codedamn.com).

## Setting up a custom email sender

Fermion provides an option to send emails from a dedicated address under your sub-domain.

<Steps>
  <Step title="Add a new domain">
    Go to **Settings > Email Senders** and add a new domain to send emails from.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/email-sender-step-1.rjbpjm.png)
  </Step>

  <Step title="Access DNS records">
    Click on the newly created sub-domain to access the DNS records required to connect Fermion with your sub-domain.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/comet_j7sDUtxa5w.rzjtgc.png)
  </Step>

  <Step title="Add DNS records to your host">
    Copy and paste the provided DNS records into the DNS section of your hosting provider.\
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/comet_ufp6vyNmxd.dspbag.png)
  </Step>

  <Step title="Verify records">
    Once the records are verified, the status will update to indicate verification, and your custom email sender will be ready to use.
  </Step>
</Steps>

## Next steps

<Columns>
  <Card title="Email Marketing">
    To expand your marketing reach, explore **email marketing** at Fermion. Learn how to create campaigns, manage use groups, and send emails by visiting the [email marketing documentation](/marketing-tools/email-marketing).
  </Card>
</Columns>


# Email Marketing
Source: https://docs.fermion.app/marketing-tools/email-marketing

Learn how to create, manage, and optimize email marketing campaigns using Fermion.

## What is Email Marketing?

Email marketing is a powerful tool for engaging your learners directly through their inbox. It allows you to send targeted messages, announcements, promotions, and updates in a personal and measurable way. At Fermion, email marketing can be especially useful for promoting new [courses](/setting-up-course/prerequisites), notifying users about [live sessions](/live-classes/what-are-live-classes) and keeping them engaged with your content. Whether you are running a large-scale learning platform or a small niche course, email campaigns help you maintain consistent communication and drive user engagement. You can also utilize [announcements](/setting-up-course/announcements) if you wish to send emails to students enrolled in a particular course.

<Check>
  Fermion offers the following email limits in paid plans:

  * **Basic Plan:** 500 emails per month. \$1 per additional 1,000 emails.
  * **Pro Plan:** 3,000 emails per month. \$0.50 per additional 1,000 emails.

  Learn more about [Fermion pricing](https://fermion.app/pricing).
</Check>

## Managing user groups in Fermion

User groups in Fermion are a way to organize your learners or users into logical segments. These groups can be based on course enrollment, subscription plans, engagement level, or any other criteria that make sense for your platform. By using user groups, you can efficiently target specific audiences when sending marketing campaigns, granting product access, or automating onboarding processes.

<Tip>
  You can use user groups to send personalized marketing emails, bulk assign or remove access to courses or products, and ensure that messages reach the right set of users.
</Tip>

### Creating and managing user groups

<Steps>
  <Step title="Navigate to User Groups">
    Head over to <strong>Marketing Tools</strong> in your Instructor Dashboard sidebar and click on <strong>User Groups</strong>. Here, you can either edit an existing user group or create a new one by clicking the **Create user group** button.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/CREATE%20USER%20GROUP.achrkv.png)
    Now, you can start adding users to these groups either directly or with the help of product enrollments. Any user who has access to the product added in the user group will be added to the user group.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/chrome_VJ134m24Mr.aomrfq.png)
  </Step>

  <Step title="Add users directly">
    You can add users individually by providing the following details:

    `Name`: The full name of the user.
    `Email`: The user’s email address, required for login and communication.
    `Phone Number` (Optional): User’s contact number, used for notifications or verification.
    `Password` (Optional): The user’s password; if left blank, a secure password will be auto-generated.
    `User Creation Timestamp` (Optional): The date and time when the user account was created.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/single%20user%20import.zqyyya.png)

    You can select the creation date, enable a welcome email, and set a custom default transactional email sender. Users imported this way can also be auto-enrolled in products and added to selected groups. Users without accounts will automatically receive their password and access details via email.
  </Step>

  <Step title="Bulk import via CSV">
    Alternatively, you can upload a CSV file containing user data to import multiple users at once. The CSV should include these columns:

    `Email` (required): The user’s email address, required for login and communication.
    `Name` (optional): The full name of the user.
    `Password` (optional, auto-generated if blank): The user’s password; if left blank, a secure password will be automatically generated.
    `Phone Number` (optional): User’s contact number, used for notifications or verification.
    `Created At` (optional): The date and time when the user account was created.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/bulk%20import.tuderc.png)
  </Step>

  <Step title="Add users via product enrollment">
    You can also add users to a group by enrolling them in a product. All users enrolled in that product will automatically be added to the user group.
    Click on **Add products to group** button and add the required product's user base to the group.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/PRODUCT%20ENR0LLMENT.yyjbjq.png)
  </Step>
</Steps>

Once your user group is created and populated with users, it is ready to be used in email marketing campaigns. You can assign this user group to a new or existing campaign, ensuring that your emails reach the intended audience.

## Creating an Email Marketing Campaign

<Steps>
  <Step title="Enable 'WhatsApp and Email Marketing' feature">
    Go to **Manage Features** in Fermion and ensure that **"Email and WhatsApp Marketing"** feature in the marketing section is enabled. Without this, you will not be able to send emails from Fermion. To learn more about enabling features, head over to [manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Navigate to email marketing">
    Go to **Marketing Tools > Email Marketing**. You can either create a new campaign or edit an existing one.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/create%20new%20campaign.stimyt.png)
  </Step>

  <Step title="Assign user group and sender">
    Select the **user group** you want to target for this campaign. This ensures that your emails reach the right audience segment. Make sure you have a **sender** available for your emails. For instructions on enabling email senders with the help of your domain, refer to [email sender configuration docs](/marketing-tools/email-automation)
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/select%20user%20group.tzoaad.png)
  </Step>

  <Step title="Compose email content">
    Write the **subject line** and **email content** for your campaign. The content editor supports rich text formatting and you can add images, links, and personalization to make your emails engaging.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/13-10-2025/dY2n3oSLPQ.kvsvzn.png)
  </Step>

  <Step title="Save and test">
    Click **Save Changes** to save your campaign. Use **Send Test Email** to preview how the email will appear to recipients before sending it out.
  </Step>

  <Step title="Start campaign">
    Once you are satisfied with your email content and testing, click **Start Campaign** to send it to your selected user group.

    Fermion will handle the **delivery** automatically, allowing you to focus on analyzing results and optimizing future campaigns.
  </Step>
</Steps>

## Where can you use email marketing?

Email marketing in Fermion can be applied in numerous scenarios. For instance, you can send onboarding emails to new learners, course reminders before live sessions, or promotional offers for advanced courses.

## Next steps

<Columns>
  <Card title="WhatsApp Marketing">
    To expand your marketing reach, explore **WhatsApp Marketing** in Fermion. Learn how to create campaigns, manage audiences, and send messages by visiting the [WhatsApp marketing documentation](/marketing-tools/whatsapp-marketing).
  </Card>
</Columns>


# Email Templates
Source: https://docs.fermion.app/marketing-tools/email-templates

Configure your email domains, reminders, and templates for system communications.

Fermion allows you to customize and automate all system-generated emails to align with your brand and improve communication with your users. From setting up reminders for [live events](/live-classes/what-are-live-classes) to editing default templates for different user actions, you have full control over how and when your platform communicates with learners and instructors.

## Live event email reminders

<Note>
  By default, all system-generated emails are sent from a **Fermion-associated email address**. If you want to use your **own domain** as the email sender, please refer to the [Email Sender Configuration](/marketing-tools/email-automation) documentation to learn how to verify and connect your domain.
</Note>

You can keep your participants informed and minimize missed sessions by enabling automatic reminder emails for all [live events](/live-classes/what-are-live-classes) hosted on Fermion.
When enabled, the system automatically sends reminder emails to all registered participants **24 hours, 6 hours, and 30 minutes** before the event begins, ensuring they have timely access to session details and joining links.

<Steps>
  <Step title="Open email sender">
    Navigate to your instructor dashboard → **Settings → Email sender**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_VjUrVuGPL4.xvfpze.png)
  </Step>

  <Step title="Locate “Live event email reminders”">
    Scroll to the section labeled **Live Event Email Reminders**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_d0Lm3hpxTp.jckcyn.png)
  </Step>

  <Step title="Enable automatic reminders">
    Turn on the toggle and click **Update setting** to start sending reminder emails to all registered participants.
  </Step>

  <Step title="Understand the schedule">
    Once enabled, [live session](/live-classes/what-are-live-classes) reminders are automatically sent **30 minutes**, **6 hours**, and **24 hours** before the event begins.
  </Step>
</Steps>

***

## Email templates

Fermion includes a library of predefined **system-generated email templates** that handle various automated communications, such as account creation, password resets, purchases, and event notifications. You can customize the content, layout, and appearance of these templates to reflect your branding and tone of voice.

The **Email Templates** section lists all available templates along with their current status : whether using the **default template** or a **custom version** you’ve edited. The following default templates are available at Fermion and you can edit all of these templates as per your requirements.

| Type                          | Description                                                     |
| ----------------------------- | --------------------------------------------------------------- |
| Live Event Host Added         | Sent when a user is added as a host for a live event.           |
| Live Event Session Reminder   | Reminder emails for upcoming live sessions.                     |
| New Account on Import         | Triggered when a user account is created through a bulk import. |
| New Account on Purchase       | Sent when a new account is created during checkout.             |
| New Community Announcement    | Sent when a new announcement is published in a community.       |
| New Product Purchase          | Confirmation for new purchases or enrollments.                  |
| OTP for Registration          | Sent to verify user identity during sign-up.                    |
| Password Updated Confirmation | Confirms successful password updates.                           |
| Pending Payment Reminder      | Sent to users with incomplete EMI payments.                     |
| Product Rating Reminder       | Encourages users to rate purchased products.                    |
| Reset Password                | Sent when a user requests a password reset.                     |
| User Group Product Assigned   | Notifies users when a product is added to their group.          |
| User Group Product Unassigned | Notifies users when a product is removed from their group.      |

***

### Editing an email template

You can also choose to edit these pre-defined templates and edit them according to your requirements with the help of the following steps:

<Steps>
  <Step title="Navigate to Email Templates">
    Go to **Settings → Email senders → Email Templates**.
  </Step>

  <Step title="Select a Template">
    Choose a system template from the list and click **Manage**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_nYytBomiMI.nbyqcm.png)
  </Step>

  <Step title="Edit content">
    You can customize the **subject line** and the **body text** to align with your brand’s tone.
  </Step>

  <Step title="Add dynamic variables">
    You can use template variables to personalize each message dynamically at the time of sending.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_y4TBDAs1co.wigjws.png)

    <Accordion title="Available template variables">
      When customizing your email templates, you can use the following variables to dynamically insert user, school, and product data.\
      These placeholders are replaced automatically when the email is sent.

      | Variable                    | Details                                                     |
      | --------------------------- | ----------------------------------------------------------- |
      | `{{productName}}`           | Title of the product that the user has purchased.           |
      | `{{productType}}`           | Type of the product.                                        |
      | `{{productUrl}}`            | URL where the user can access the product.                  |
      | `{{schoolId}}`              | ID of your school.                                          |
      | `{{schoolName}}`            | Name of your school.                                        |
      | `{{schoolHostname}}`        | Hostname (domain) of your school.                           |
      | `{{schoolLogoUrl}}`         | URL of your school’s logo image.                            |
      | `{{schoolPhysicalAddress}}` | Physical address of your school.                            |
      | `{{userId}}`                | ID of the user.                                             |
      | `{{userFullName}}`          | Full name of the user.                                      |
      | `{{userFirstName}}`         | First name of the user.                                     |
      | `{{userLastName}}`          | Last name of the user.                                      |
      | `{{userUsername}}`          | Username of the user.                                       |
      | `{{userEmail}}`             | Email address of the user.                                  |
      | `{{emailUnsubscribeUrl}}`   | URL that allows the user to unsubscribe from future emails. |
      | `{{emailTrackingLogoUrl}}`  | URL of the logo image used to track email open counts.      |
      | `{{emailFromAddress}}`      | Email address from which the message is sent.               |
      | `{{emailFromName}}`         | Display name that appears alongside your sender address.    |
      | `{{emailReplyToAddress}}`   | Email address where user should reply                       |
    </Accordion>
  </Step>

  <Step title="Preview and Save">
    Review your edits using the built-in preview, then click **Save changes** to apply your changes.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-10-2025/chrome_4PZJb1CLFM.gjgnzd.png)
  </Step>
</Steps>

Now your custom template will be used to send an email automatically whenever the respective event occurs.

<Note>
  All customized templates override the system defaults. You can restore the default content anytime by selecting **Reset** from the Manage Template view.
</Note>

## Next steps

<Columns>
  <Card href="/marketing-tools/email-marketing" title="Email Marketing">
    Learn how to create campaigns, track performance, and reach your users effectively via email.
  </Card>

  <Card title="WhatsApp Marketing" href="/marketing-tools/whatsapp-marketing">
    Discover how to send messages and notifications to users via WhatsApp.
  </Card>
</Columns>


# WhatsApp Marketing
Source: https://docs.fermion.app/marketing-tools/whatsapp-marketing

Connect your WhatsApp Business account to Fermion and send automated class reminders to your students.

## Introduction

WhatsApp Marketing allows you to connect your WhatsApp Business account to Fermion and send automated reminders for your [live classes](/live-classes/what-are-live-classes).
In today's fast-paced world, students often miss live sessions due to forgetfulness or busy schedules. By integrating WhatsApp, you can ensure timely notifications and increase attendance rates, improving engagement and student satisfaction.

## Connecting WhatsApp Business to Fermion

Follow these steps to link your WhatsApp Business account to Fermion and enable automatic class reminders.

<Steps>
  <Step title="Enable WhatsApp and Email Marketing Features">
    Go to **Manage Features** in Fermion and ensure that **"Email and WhatsApp Marketing"** feature in the marketing section is enabled. Without this, you will not be able to connect to WhatsApp or send automated reminders. To learn more about enabling features, head over to [manage features](/manage-settings/manage-features)
  </Step>

  <Step title="Navigate to WhatsApp marketing">
    Go to **Marketing Tools → WhatsApp Marketing** in your instructor dashboard. Click on **Set up WhatsApp Account** to connect your WhatsApp account with Fermion
    ![Start whatsapp marketing](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/setupwhatsappmarketing.hnapzt.png)
  </Step>

  <Step title="Log in to Meta account">
    You will be redirected to Meta to log in with your account. Use the credentials associated with your WhatsApp Business account.
    ![Sign in at Meta](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/qH8Jb5WLmP.wkjvdr.png)
  </Step>

  <Step title="Connect your account ">
    To connect your WhatsApp Business account with codedamn, you’ll need to complete the Meta Cloud API onboarding process.\
    Click on **Continue** to proceed with registration and grant access.

    <AccordionGroup>
      <Accordion title="What you'll be able to do after connecting">
        Once your account is connected, you can:

        * Communicate with customers at scale through automated conversations.
        * Securely send and receive messages using Meta’s Cloud API.
        * Handle large volumes of WhatsApp messages with ease.
      </Accordion>
    </AccordionGroup>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/37%E2%80%AFAM.jqcuoe.png)
  </Step>

  <Step title="Fill in business information">
    Please enter the business information concerned with your school. Your audience will not see this information on your WhatsApp profile.
    Add your own business name, email address, website URL and the country the business is operated from.
    <Note> The data shown in the image is for illustration purposes only. Make sure to replace it with your own business information in the appropriate fields. </Note>
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/add%20business%20details.fikjlq.png)
  </Step>

  <Step title="Choose WhatsApp Business account">
    Decide which WhatsApp Business account will belong to your business portfolio. You can either select an existing account or create a new WhatsApp Business profile.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/create%20whatsapp%20account.urxrrl.png)

    <AccordionGroup>
      <Accordion title="Create a new WhatsApp Business profile">
        * Profile Name: Fermion Academy - Example
        * Display Name: Fermion Academy - Example (should match business name and follow WhatsApp display name guidelines)
        * Category: Select the category that best describes your business
          ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/create%20whatsapp%20business%20profile.gglyjn.png)
          Click on Next to move to the next step!
      </Accordion>
    </AccordionGroup>
  </Step>

  <Step title="Add your WhatsApp phone number">
    Add the phone number you want to use for sending and receiving WhatsApp messages. Choose your country code, enter your business phone number, and verify it to proceed. You can choose how you’d like to verify your number: either via **Text message** or **Phone call**. Once selected, you’ll receive a verification code from Meta to confirm ownership of the number.

    <Warning>Make sure the number you provide is **not already associated** with an existing WhatsApp account. If it is, you’ll need to deactivate that account before verification.</Warning>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/52%E2%80%AFAM.torivc.png)
  </Step>

  <Step title="Review permissions shared with Fermion">
    Before completing the setup, review the permissions that will be granted to Fermion. This ensures Fermion can manage and automate your WhatsApp Business interactions through Meta’s Cloud API.

    Fermion is requesting access to your **WhatsApp Business account**. Once you confirm, Fermion will be able to:

    * Manage your WhatsApp accounts
    * Manage and access conversations within WhatsApp
    * Log events on your WhatsApp Business account’s behalf and send those events to Meta

    Click **Confirm** to grant these permissions and proceed with connecting your account.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/11skFHyDtD.udjpfr.png)
  </Step>

  <Step title="Add payment methods">
    Before proceeding, make sure to add a payment method and complete your business details. This step is mandatory to finalize the connection with WhatsApp.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/jJ9sT6SNeb.lunfmq.png)
  </Step>

  <Step title="Add Business and GST Details alongside Payment Method">
    Before you can finalize the WhatsApp Business connection, you must add your business details, GST information, and a payment method.

    <Warning> Adding GST details is mandatory. Without providing valid GST information, the setup will not work and you will not be able to send messages through WhatsApp Business.</Warning>

    Make sure to:

    * Click on **Add Payment method** to add a payment method
    * Click on **Edit** in Business info to add correct and updated information about your details
    * Enter your GST number correctly.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/EiYfXPWDAv.odblfc.png)
  </Step>

  <Step title="Finish setup">
    Click **Finish**. Your WhatsApp Business account is now linked to Fermion and ready to send live class reminders.
  </Step>
</Steps>

And here you go, your WhatsApp account is now linked with [Fermion](https://fermion.app) and you can start sending messages on WhatsApp directly inside Fermion.

For additional reference, see the following Meta resources:

<Columns>
  <Card title="Meta Business Help Centre">
    Access Meta’s official help documentation for general business account questions and troubleshooting.
    [Click here to learn more](https://www.facebook.com/business/help)
  </Card>

  <Card title="Business Portfolio at Meta">
    Learn more about managing your business portfolio, messaging limits, and related settings on Meta.
    [Click here to learn more](https://www.facebook.com/business/help/1710077379203657)
  </Card>
</Columns>

## Sending live class reminders

Once your WhatsApp Business account is connected to Fermion, you can start sending automated reminders for your [live sessions](/live-classes/what-are-live-classes). Follow these steps to create and link a WhatsApp message template for your class reminders.

<Steps>
  <Step title="Create a WhatsApp message template">
    Go to the **Message Templates** section under **Marketing Tools → WhatsApp Marketing** and click **Create Template**.

    In this section, you can design a new message template using dynamic variables such as session name, start time, and participant name.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_vFmeKYw4qC.ucjvev.png)
  </Step>

  <Step title="Customize your template">
    Preview the message on the right side to see how it will look to your students.\
    Make sure your tone is friendly and professional, and all dynamic variables are correctly inserted.

    <Info>
      Templates are usually reviewed and approved within **a few seconds**, but sometimes the process can take **up to 24 hours** depending on WhatsApp’s moderation queue.
    </Info>

    **Example Template:**

    * **Template Name:** `live_session_reminder`
    * **Header (Optional):** *Live Session Starting Soon*
    * **Body:**
      ```
      Hi {{participantName}},

      Your live session "{{sessionName}}" starts at {{sessionStartTime}} 
      in {{timeUntilStart}}.

      Don't miss out on this exclusive learning opportunity! 
      Join us for an interactive session where you can ask questions 
      and engage with the instructor.
      ```
    * **Footer (Optional):** `Powered by Fermion`
    * **Button Text (Optional):** `Join Live Session`

      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_P6bcJZTxRo.hzsuyw.png)

    ### Template Variables

    When creating your WhatsApp message template, you can use dynamic variables to automatically personalize each reminder. These variables are replaced with real data for every student and session, making each message feel tailored and professional.

    Below are the variables currently supported in Fermion WhatsApp templates:

    | Variable               | Description                                                                    |
    | ---------------------- | ------------------------------------------------------------------------------ |
    | `{{participantName}}`  | Automatically inserts the participant’s full name.                             |
    | `{{schoolName}}`       | Displays the name of your school                                               |
    | `{{sessionName}}`      | Displays the name of the live session.                                         |
    | `{{sessionStartTime}}` | Shows the exact start time of the live session.                                |
    | `{{timeUntilStart}}`   | Displays how much time is left before the session starts (e.g., “30 minutes”). |

    <Warning>
      **Currently, only utility templates are supported.** These are templates for notifications or reminders.

      If you try to create a **marketing or promotional** template (e.g., discounts, offers, etc.), **WhatsApp will reject it.** If you need help setting up marketing templates, please contact our team at ([support@codedamn.com](mailto:support@codedamn.com)).
    </Warning>

    Once done, click **Save Template** to store it in your WhatsApp marketing template library. Your template will now be sent to WhatsApp for approval and would take some time to get approved by Meta.

    Meta typically reviews and approves message templates within a few minutes to a few hours. In some cases, it may take up to 24 hours for approval.
  </Step>

  <Step title="Toggle Live Session reminder and link a template">
    After saving the template and getting it approved by Meta, Toggle the **Live Session Reminders** button and link the created template to the reminder. At a particular moment, you can only link 1 template to the live session reminder.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/44___pm__2_.ojxwis.png)
  </Step>

  <Step title="Start sending reminders">
    Once linked, Fermion will automatically send WhatsApp reminders to all enrolled participants before the live session starts.
  </Step>
</Steps>

And that’s it! You’re all set to start sending WhatsApp reminders straight from Fermion. No more missed classes or last-minute confusion.

## Messaging limits

By default, Meta allows you to send up to **250 messages/day** from a single WhatsApp Business number. This ensures that your account remains in good standing and prevents spam or abuse.

However, this daily limit can be increased as your business grows by verifying your business account with Facebook Business Manager and scaling your message tiers. Increasing your messaging limit allows you to reach more students or participants efficiently without interruptions.

To learn more about how messaging limits work and how to request higher limits, refer to the official Meta documentation:\
[Learn more about WhatsApp messaging limits](https://developers.facebook.com/docs/whatsapp/messaging-limits/)

<Tip>
  In addition to getting verified on Facebook Business Manager, you can also increase your messaging limit by sending **high-quality messages** to at least **1,000 unique users over a rolling 7-day period**.
</Tip>


# Account Setup
Source: https://docs.fermion.app/onboarding/account-setup

Learn how to create and configure your instructor account, manage school settings, and ensure your account is ready to start creating courses.

## Introduction

Welcome to Fermion! This section will guide you through everything you need to know to get started with your account and set up your first course.
Fermion offers a robust platform with a wide range of features, including recorded and cohort based courses, live classes, coding labs, forms, analytics,
and white-labeled accounts for a fully branded experience.

All account setup and configurations - including custom domains and whitelabeling are performed only on **production-level accounts**. If you are currently on a trial account,
our team will seamlessly transition your account to a production environment once you subscribe to a plan, ensuring a smooth onboarding experience.

## Account setup

Setting up an account on Fermion is quick and straightforward. Typically, the entire process takes **30–40 minutes** and is
handled by the Fermion team, so you can start exploring the platform without any technical hurdles.
By the end of this process, you will have access to your dashboard under your own branded domain (if applicable)
and be ready to create and manage your courses efficiently.

As soon as the account is set up, our team will reach to you over WhatsApp and provide the relevant details for you to access the platform.
We recommend that you go through the [Platform Resources](/onboarding/platform-resources) to ensure a smooth start at Fermion

Once your account is ready, you can log in to your personalized dashboard where
you’ll manage courses, coding labs, live sessions, billing, school settings, and more.

![Instructor Dashboard](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/18-11-2024/18%E2%80%AFPM.nbcqlj.png)

<Steps>
  <Step title="Access your dashboard">
    After logging in, you’ll land on the **instructor dashboard**, which is your control center for everything on Fermion.\
    From here, you can create [courses](/setting-up-course/prerequisites), configure [labs](/creating-coding-labs/what-are-coding-labs), run [live sessions](/live-classes/what-are-live-classes), and manage school-wide [settings](/manage-settings/change-school-settings).
  </Step>

  <Step title="Manage features">
    One of the first things you’ll notice is the **Manage Features** button.

    This allows you to enable or disable key modules of your account based on your needs.\
    For example, you can turn on [bundles](/setting-up-course/bundle), enable [live classes](/live-classes/what-are-live-classes), activate [coding labs](/creating-coding-labs/what-are-coding-labs), or experiment with [forms](/forms/introduction).

    ![Manage Features](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/manage%20features.qlanmr.png)
  </Step>

  <Step title="Customize your experience">
    By selecting the features you want, your dashboard stays focused on the tools you actually use, while still giving you the flexibility to expand later as your requirements grow.

    Click on **Save Changes** to apply your customizations.

    ![Features](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/features.kgaywp.png)
  </Step>

  <Step title="You’re all set!">
    Your **Fermion account** is now ready to go.

    With your dashboard live, features enabled, and branding in place, you can immediately start creating courses, running live sessions, and engaging with learners.
  </Step>
</Steps>

To make the most of your new account, check out the [Platform Resources](/onboarding/platform-resources) and watch the [Demo Video](https://www.youtube.com/watch?v=9b31PJRfuqc) for a walkthrough of the key features.

***

Here are some of the most common questions we receive about setting up your account on Fermion:

## Account setup FAQs

<Accordion title="Who will set up the account for me?">
  Our team will create your account with initial login credentials and a platform URL.
  Details will be shared via WhatsApp. We recommend watching the [Demo Video](https://www.youtube.com/watch?v=9b31PJRfuqc) to get started quickly.
</Accordion>

<Accordion title="How long does it take to set up the account?">
  Once you join Fermion, your account is usually set up within 30 minutes by the Fermion team. You will receive your login credentials and access details via a WhatsApp channel.
</Accordion>

<Accordion title="Do I need to be technical to operate Fermion?">
  No technical expertise is required. Fermion is designed to be intuitive and user-friendly for creators of all levels.
</Accordion>

<Accordion title="How can I request a trial account to test out features?">
  Trial accounts can be requested by booking a demo at [Fermion - schedule a demo](https://fermion.app/schedule-a-demo). We’ll guide you through the process to get started quickly.
</Accordion>

<Accordion title="How long does a trial account last?">
  Trial accounts are valid for **7 days** from the time of activation.
</Accordion>

<Accordion title="How do we get a custom domain name or white-labelling for our LMS?">
  Available for customers on a paid plan, our team will help set up your custom sub-domain.
  The process typically takes 30–40 minutes depending on DNS verification by your domain provider, after which your LMS will be live with your branding.
</Accordion>

<Accordion title="How can I set up my first course?">
  Follow our [Course Setup Guide](/setting-up-course/prerequisites) for step-by-step instructions, check [Course FAQs]() for common questions, and refer to [Setup Pricing](/setup-pricing/fixed-pricing-plan) to configure your course pricing.
</Accordion>

<Accordion title="How do I get paid?">
  Detailed documentation regarding payouts can be accessed here: [How do you get Paid?](/manage-settings/manage-payouts)
</Accordion>

<Accordion title="How can I reach out to the team over email?">
  You can contact our support team directly at [support@codedamn.com](mailto:support@codedamn.com) for any questions or assistance.
</Accordion>

<Accordion title="Can I collect payments and conduct live sessions on a trial account?">
  Yes, trial accounts allow you to collect payments and run live sessions, but usage is limited. We recommend moving to a paid plan for the best experience.
</Accordion>

<Accordion title="Does Fermion provide web design or web development support?">
  No, Fermion does not provide custom web design or development services. Our platform is ready-to-use and doesn’t require coding.
  We do offer the ability to add custom CSS for certain elements and complete whitelabeling when it comes to branding.
</Accordion>

<Accordion title="Does Fermion provide a mobile application?">
  Yes! Fermion offers an on-demand custom native mobile apps. For more information, check our [Pricing](https://fermion.app/pricing) page.
</Accordion>

***


# Platform FAQs
Source: https://docs.fermion.app/onboarding/common-faqs

Frequently asked questions about Fermion platform

## Getting started

Fermion is designed to be user-friendly and accessible to everyone.
Here are some commonly asked questions about getting started and the types of content you can create.

<Accordion title="Do I need technical knowledge to use Fermion?">
  No, Fermion is designed to be user-friendly and requires no coding knowledge for basic operations. However, advanced features like custom CSS styling and API integrations are available for those who want more control.
</Accordion>

<Accordion title="How long does it take to set up my school?">
  Basic setup can be completed in a few hours. For more complex customizations and integrations, refer to our turnaround time documentation.
</Accordion>

<Accordion title="Where can I find tutorials and documentation?">
  You can access comprehensive documentation at [docs.fermion.app](https://docs.fermion.app), which includes guides, tutorials, and API references.
</Accordion>

<Accordion title="Is there an onboarding process at Fermion?">
  Yes, Fermion provides a structured onboarding process to help you set up your school, configure settings, and launch your first course successfully. Learn more about [Onboarding at Fermion](/onboarding/account-setup)
</Accordion>

<Accordion title="What types of content can I create on Fermion?">
  You can create:

  * [Live classes](/live-classes/what-are-live-classes) with up to 10,000 participants
  * [Recorded video](/recorded-videos/introduction) courses with DRM protection
  * [Interactive coding labs](/creating-coding-labs/what-are-coding-labs) (HTML/CSS, React, Node, Python, Java, Rust)
  * [IO coding labs](/creating-io-coding-labs/introduction) (C, C++, Java, SQL and other languages)
  * [Ebooks](/digital-products/introduction)
  * [Community spaces](/community/what-are-communities)
  * [Custom landing pages](/custom-landing-pages/introduction)
  * [Forms](/forms/introduction)
</Accordion>

## Live classes

Fermion offers powerful live classes for your students.
These FAQs cover everything from session limits to co-instructors, recordings, and video quality.

You can learn extensively about this feature at [Live Classes](/live-classes/what-are-live-classes)

<Accordion title="How many students can attend my live class?">
  Fermion supports up to 10,000+ students in a single live session with smooth, uninterrupted streaming. Learn more about creating your first live class [here](/live-classes/setup-live-class)
</Accordion>

<Accordion title="Can I invite co-instructors or guests to my live class?">
  Yes, you can invite up to 150 participants to the stage during a live session. They can share their screen, turn on their camera, and use their microphone. Learn more about [stage](/live-classes/invite-to-stage).
</Accordion>

<Accordion title="Is there a time limit for live classes?">
  No, there is no restriction on the duration of your live classes. You can teach for 6+ hours in a single session.
</Accordion>

<Accordion title="Are live classes automatically recorded?">
  Yes. Once your live session ends, Fermion automatically generates a video recording and makes it available to your students.
  You can also enable AI-generated captions in the same language used during the stream.
  These recordings can also be made available for your students to download as MP4 files.
  Learn more about [Auto Recording and Captions](/live-classes/recording-and-captions).
</Accordion>

<Accordion title="What video quality is supported for live streaming?">
  Fermion supports streaming up to 1080p resolution for your live classes.
</Accordion>

## Video content & security

Your video content is protected and easy to manage. Here are some FAQs about DRM, watermarking, AI captions, and embedding videos securely.

You can learn more about DRM protection and captions at [Video Streaming](/recorded-videos/introduction)

<Accordion title="How is my video content protected?">
  Fermion provides built-in DRM (Digital Rights Management) support to protect your content from piracy and unauthorized sharing.
  You can also enable video watermarking to identify anyone sharing or pirating your content. More information on this feature can be found here [DRM and Watermarking](/live-classes/drm-and-watermarking)
</Accordion>

<Accordion title="Can I add captions to my recorded videos?">
  Yes, Fermion offers AI-generated captions for recorded videos. You can enable this feature when uploading or processing your videos. Learn how to enable captions [here](/recorded-videos/captions)
</Accordion>

<Accordion title="Can I embed videos outside of Fermion?">
  Yes, you can embed both live sessions and recorded videos on external websites using Fermion's white-labeled embedding options. You can learn more about video embedding options at [How to embed a video externally](/recorded-videos/embed-video)
</Accordion>

## Coding labs

Fermion supports interactive and IO coding labs for multiple programming languages.
These FAQs explain the difference between lab types and various supported languages.

You can learn more about this feature at [Coding Labs](/creating-coding-labs/what-are-coding-labs)

<Accordion title="What programming languages are supported in coding labs?">
  Fermion supports interactive coding labs for:

  * HTML/CSS
  * JavaScript/Node.js
  * React
  * Python
  * Java
  * Rust
  * SQL (IO labs)
</Accordion>

<Accordion title="What are the differences between Interactive and IO coding labs?">
  * [**Interactive labs:**](/creating-coding-labs/what-are-coding-labs) Provide a full development environment in the browser with live preview (ideal for web development)
  * [**IO labs:**](/creating-io-coding-labs/introduction) Focus on input/output testing, perfect for algorithmic problems and SQL queries
</Accordion>

## Payments & pricing

Managing student payments and course pricing is straightforward on Fermion.
These FAQs cover payouts, custom pricing, and affiliate program options.

Get more information about [Payments](/setup-pricing/fixed-pricing-plan)

<Accordion title="How do I receive payments from my students?">
  Fermion integrates with payment gateways to process student payments. You can manage your payouts from the instructor dashboard under payout settings.
</Accordion>

<Accordion title="How long does it take for payouts to be credited?">
  Fermion settles payouts within 24 hours from our end. Banks typically take an additional 3-4 business days to credit the amount to your account. Refer to [Payouts](/manage-settings/manage-payouts) section for more information
</Accordion>

<Accordion title="Can I create custom pricing for my courses?">
  Yes, you have full control over your course pricing. You can also set up affiliate marketing programs and offer discounts. Learn more about [Custom Pricing](/setup-pricing/fixed-pricing-plan)
</Accordion>

## Technical support

Need help? Fermion offers structured support for technical, product, and account-related issues.
These FAQs explain support hours and contact methods.

Learn about Fermion's support strategy here: [Support](/onboarding/support-strategy)

<Accordion title="What are the support hours?">
  Standard support is available Monday to Saturday, 9 AM to 9 PM IST. Critical issues are monitored 24/7.
</Accordion>

<Accordion title="How can I contact support?">
  You can reach Fermion support through:

  * WhatsApp (details shared during onboarding)
  * Email: [support@codedamn.com](mailto:support@codedamn.com)
</Accordion>

<Accordion title="Do we have a Discord server for Fermion users?">
  Yes! You can connect with our community and team on our [Discord server](https://discord.com/invite/Sf45Hz38eB) for real-time support, discussions, and feature updates.
</Accordion>

## Customization

Make your Fermion school your own. These FAQs explain branding, custom CSS, landing pages, redirects, and domains.

Learn more about [Custom CSS](/manage-settings/custom-css-styling) and [Custom Pages](/custom-landing-pages/introduction)

<Accordion title="Can I customize the look of my school?">
  Yes, Fermion allows you to:

  * Add custom CSS styling
  * Create custom landing pages
  * Set up custom redirects
  * Add custom links
  * Use your own domain
</Accordion>

## Marketing & growth

Grow your academy with Fermion’s built-in marketing tools.
These FAQs cover affiliate programs, email integrations, and analytics.

Learn more about [Marketing Tools](/marketing-tools/affiliate-marketing)

<Accordion title="Does Fermion support affiliate marketing?">
  Yes, Fermion has built-in affiliate marketing capabilities. You can set up and manage affiliate programs directly from your dashboard.
  Refer to [Affiliate Marketing Guide](https://docs.fermion.app/marketing-tools/affiliate-marketing#affiliate-system-for-your-online-academy)
</Accordion>

<Accordion title="Can I integrate with email marketing tools?">
  Yes, Fermion supports email automation and can integrate with various marketing tools through webhooks and API. Refer to [Email marketing](/marketing-tools/email-marketing) for more information regarding this
</Accordion>

<Accordion title="What analytics are available?">
  Fermion provides comprehensive analytics including:

  * Student attendance and engagement
  * Stream analytics (drop-off rates, peak viewers)
  * Course completion rates
  * Revenue and sales data
</Accordion>

## Community features

Fermion enables community engagement and collaboration.
Here you’ll find answers about student chats, forums, and interactive features.

Here you can find more information about [Communities on Fermion](/community/what-are-communities)

<Accordion title="Can I create a community for my students?">
  Yes, Fermion includes community features where students can interact, ask questions, and engage with each other and instructors. Learn more about [communities](/community/what-are-communities)
</Accordion>

<Accordion title="Can students chat during live classes?">
  Yes, live classes include a real-time chat feature where students can send messages, share attachments, and participate in polls. [Learn more about chat](/live-classes/live-chat)
</Accordion>


# Platform Resources
Source: https://docs.fermion.app/onboarding/platform-resources

Explore all the resources available on the platform, including guides, documentation, and videos to enhance your experience with Fermion

To help you get started on Fermion and make the most of the platform, we highly recommend exploring the following resources. We suggest starting with the [**Demo Video**](https://www.youtube.com/watch?v=9b31PJRfuqc) for a quick overview, and then diving into the [**Platform Playlist**](https://www.youtube.com/playlist?list=PLWZLAvrJOOLn0xzN6ZlsWZiipXd_KAVQK) for a more detailed walkthrough of features.

***

## Documentation & troubleshooting

All of Fermion’s functionalities, including detailed guides and troubleshooting tips,
are comprehensively documented at [docs.fermion.app](https://docs.fermion.app).
This should be your primary reference whenever you need clarification or step-by-step instructions.

For example, if you face playback issues with recorded videos, the [Video Troubleshooting](https://docs.fermion.app/recorded-videos/troubleshooting-playback)
section can help resolve them quickly.

Stay up to date with platform improvements and product changes through the [Changelog](https://docs.fermion.app/changelog).

***

## Platform demo video

The **Platform Demo Video** provides a comprehensive overview of Fermion,
covering most of the platform’s essential features and functionalities.\
It walks you through key workflows, including [course creation](/setting-up-course/prerequisites), [pricing setup](/setup-pricing/fixed-pricing-plan),
[coding labs](/creating-coding-labs/what-are-coding-labs), [live classes](/live-classes/what-are-live-classes) and more, giving you a clear understanding of how to navigate
and use the platform effectively.You can watch the demo video below:

<iframe title="YouTube video player" />

***

## Platform playlist

Once you’ve watched the demo and want to explore Fermion’s features in more detail,
check out our **Platform Playlist**:

<iframe title="YouTube video player" />

<Tip>
  Best practices

  We recommend using these resources as your first point of reference whenever you encounter questions or challenges on Fermion.

  Watch the [**Demo Video**](https://www.youtube.com/watch?v=9b31PJRfuqc)  first to get a quick understanding, then explore the [**Playlist**](https://www.youtube.com/playlist?list=PLWZLAvrJOOLn0xzN6ZlsWZiipXd_KAVQK) for deeper insights.

  Always consult the documentation while exploring the platform hands-on.This approach will help you build a strong foundation, reduce friction,
  and ensure you have quick access to all the features of Fermion.
</Tip>

***

## Customer success and support

We are here to make your onboarding smooth and help you get the most out of Fermion!

Reach out to us at **[support@codedamn.com](mailto:support@codedamn.com)** for any questions.

You can also connect with our community and team on our [Discord server](https://discord.com/invite/Sf45Hz38eB) for real-time support, discussions, and feature updates.

Our team is happy to assist you with setup, troubleshooting, or best practices, ensuring that you can navigate the platform efficiently and confidently.


# Support Strategy
Source: https://docs.fermion.app/onboarding/support-strategy

Understand the platform’s support strategy, including available help channels, escalation processes, and best practices for getting assistance.

Fermion is committed to providing timely and effective support to ensure you have a smooth experience on our platform.
Our support is structured to cover technical issues, product guidance, and account or billing-related queries, so you
can get help with whatever you need, whenever you need it.

## Support availability

For our **Indian customers**, standard support is available
**Monday through Saturday, from 9 AM to 9 PM IST**, ensuring that queries are addressed promptly during local business hours.
Critical issues are monitored **24/7**, and direct call support is provided depending on the urgency of the situation.

For our **global customers**, we understand that time zones may differ,
so we strive to find overlapping hours to provide real-time support wherever possible.
Whether you need help troubleshooting a platform bug, understanding a product feature,
or resolving billing questions, our team is ready to assist.

***

## Support channels

The primary channels to reach us include **WhatsApp** for quick and direct communication (The WhatsApp group is created during onboarding). You can also reach support directly using the **Chat** icon in your instructor dashboard.

<div>
  <img alt="Fermion Support Chat Example" />
</div>

We are also available at ([support@codedamn.com](mailto:support@codedamn.com)) if email is the preferred channel of communication.

You can also connect with our community and team on our [Discord server](https://discord.com/invite/Sf45Hz38eB) for real-time support, discussions, and feature updates.

***


# Troubleshooting Mechanism
Source: https://docs.fermion.app/onboarding/troubleshooting

A curated list of resources and references to help you identify and resolve common issues on the platform efficiently.

Fermion is built to be reliable, but we know that technical or operational challenges can sometimes arise.\
This section is designed as your first stop for resolving common issues on your own, with clear documentation,
step-by-step guides, and demo videos to help you get back on track quickly without waiting for support.

## Troubleshooting resources

If you’re just getting started, the [Fermion Documentation](https://docs.fermion.app) is the best place to begin.\
It contains detailed guides, FAQs, and configuration instructions covering everything from course setup to advanced platform features.

We also recommend watching our [Demo Video](https://www.youtube.com/watch?v=9b31PJRfuqc), which provides an overview of the onboarding process,
core features, and setup best practices. This video is especially helpful if you’re new to Fermion and want a quick walkthrough of how things work.

For more specific issues, such as recorded videos not playing, buffering, or showing access restrictions,
we have a dedicated [Video Streaming Troubleshooting Guide](https://docs.fermion.app/recorded-videos/troubleshooting-playback).\
This guide walks you through common causes of playback errors and provides practical steps to resolve them.

## When to reach out

Our goal is to empower you to solve problems independently wherever possible. That’s why we’re continuously expanding our troubleshooting library across all key features,
including account setup, course creation, payments, live sessions, and mobile access. Each guide outlines common problems, their causes, and step-by-step solutions.

If you ever run into an issue that isn’t covered in the documentation, you can always reach out to our support team with the help of **WhatsApp** channel or you can email us at **[support@codedamn.com](mailto:support@codedamn.com)**


# Turnaround Time
Source: https://docs.fermion.app/onboarding/turnaround-time

Get insights into expected response times for support requests and other platform processes to plan your workflow effectively.

This section explains how Fermion handles issues, from bugs to feature requests, and outlines the expected response and resolution times, along with the escalation process.

## Support turnaround time and escalations

At Fermion, we prioritize addressing issues promptly and keeping you informed every step of the way. For bugs, our response and resolution times depend on the severity of the problem:

<Accordion title="Critical">
  Critical issues, such as the platform being down or a major feature failing, are acknowledged immediately, with a resolution target of within **12 hours**.
</Accordion>

<Accordion title="High">
  High-priority issues that affect core workflows are typically resolved within **2–3 days**.
</Accordion>

<Accordion title="Low">
  Low-priority issues, such as minor inconveniences or UI/UX concerns, are usually addressed within **1–2 weeks**.
</Accordion>

## Feature requests

New feature requests are acknowledged within **12 hours** of submission. Each request is reviewed and prioritized during our **daily product roadmap discussions**, and the implementation timeline depends on factors such as complexity, feasibility, and existing workload.

This structured approach ensures that all issues are handled efficiently and escalated appropriately, giving you confidence in timely support and clear communication.


# Enable AI Powered Captions
Source: https://docs.fermion.app/recorded-videos/captions

Step-by-step guide to enable AI-generated captions for recorded videos on Fermion.

<Steps>
  <Step title="Go to Video Library">
    Navigate to **Dashboard → Recorded Videos → Video Library** to view all your uploaded recordings.
  </Step>

  <Step title="Open Video Settings">
    Find the video you want to caption and click the **Settings (⋮)** icon next to it.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/hMABELzS1l.ikepqt.png)
  </Step>

  <Step title="Select AI Transcription">
    In the video settings panel, toggle the **enable AI transcription for this video** option to automatically generate captions in the same language used within the video.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_Gk19ptvP7t.vofrry.png)
  </Step>

  <Step title="Wait for Processing">
    Fermion will begin transcribing your video automatically.\
    The processing time depends on the video length.
  </Step>
</Steps>

***

### Global Settings for Captions

You can also enable this feature globally for all recorded videos uploaded to your school.

<Steps>
  <Step title="Open School Settings">
    Navigate to **Dashboard → Settings → School Settings → Recorded Video Settings**.
    ![global-captions-toggle](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_LNO75xKmlS.hpzxjm.png)
  </Step>

  <Step title="Enable Global AI Transcription">
    Toggle **Enable AI Transcripts** to automatically generate captions for every video uploaded under your school.
  </Step>
</Steps>

***

<Note>
  Fermion **Pro** includes 5 hours of AI transcription. Additional usage is billed at **\$0.30/hour**. Learn more at [Fermion Pricing](https://fermion.app/pricing)
</Note>


# Embed Recorded Videos
Source: https://docs.fermion.app/recorded-videos/embed-video

Learn how to integrate Fermion recorded videos into your website using our SDK, including public and private video embedding options with origin whitelisting.

This guide explains how to embed recorded videos into external websites using the Fermion SDK.

<Info>
  The Fermion SDK is open source and available on GitHub:
  [github.com/fermion-app/sdk](https://github.com/fermion-app/sdk)
</Info>

## Prerequisites

* Video ID from your Fermion dashboard
* Fermion API key (only if you disable public embeds)
* Access to your website's codebase
* Your website domain (for origin whitelisting - optional but recommended)

## Step 1: Enable [Video Library](/recorded-videos/video-library) and Get Video ID

First, go to `Manage features` tab on your instructor dashboard and enable `Video library`:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/16-02-2025/screenshot-001155.joduvu.png)

After that, go to `Video library` and upload a video if you haven't:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/16-02-2025/screenshot-001156.reocnd.png)

Each video on Fermion has a unique identifier (e.g., `6779080e80ec97e953a17971`). You'll need this ID for embedding.

## Step 2: Configure Origin Whitelisting (Optional)

For enhanced security, you can configure origin whitelisting to control which domains are allowed to embed your videos. This is especially useful for public embeds to prevent unauthorized usage.

### Per-Video Origin Whitelisting

You can set a whitelisted origin for individual videos:

1. Go to your video settings
2. In the **Video Settings** section, find the **Whitelisted origin (optional)** field
3. Enter the domain where you want to embed the video (e.g., `https://example.com`)
4. Make sure **Allow public embeds** is enabled if you want the video to be publicly embeddable

<Note>
  If you specify a whitelisted origin, only that domain will be allowed to
  embed your video. Leave empty to allow all origins. Domain restrictions do
  not apply when using JWT signed tokens - signed embeds will always work
  regardless of origin whitelisting settings.
</Note>

### Global Origin Whitelisting

You can also set a default whitelisted domain for all your videos:

1. Click on **Modify global settings for videos**
2. In the **Global video settings** modal, enter your domain in the **Whitelisted domain for embedding videos externally (optional)** field
3. Click **Save Changes**

<Info>
  If specified, this domain will be used as the default whitelisted origin for
  all videos that don't have a specific whitelisted origin set. Leave empty to
  allow all origins by default. **Note: JWT signed tokens always bypass domain
  restrictions.**
</Info>

## Step 3: Install the SDK

```bash theme={null}
npm install @fermion-app/sdk
# or
yarn add @fermion-app/sdk
# or
pnpm add @fermion-app/sdk
```

## Step 4: Basic Video Embedding

### Public Video Embedding

For public videos, you can use the following code:

```typescript theme={null}
import { FermionRecordedVideo } from '@fermion-app/sdk/recorded-video'

// Create a video instance
const video = new FermionRecordedVideo({
	videoId: 'your-video-id',
	websiteHostname: 'your-domain.fermion.app',
})

// Get the embed code
const publicEmbed = video.getPubliclyEmbedPlaybackIframeCode()
console.log(publicEmbed.iframeHtml)
```

<Info>
  When using public embeds with origin whitelisting enabled, make sure your
  website domain matches the whitelisted origin you configured in Step 2. If
  there's a mismatch, the video embed will not work.
</Info>

### Private Video Embedding

If your video is not public, you'll need to generate a JWT token for authentication:

```javascript theme={null}
import jwt from 'jsonwebtoken'

const payloadObject = {
	type: 'external-embed',
	videoId: 'your-video-id',
	userId: 'unique-user-id',
}

const jwtToken = jwt.sign(payloadObject, 'FERMION_API_KEY', {
	expiresIn: '10h',
})
```

<Note>
  Important notes: - Replace `FERMION_API_KEY` with your actual API key -
  Provide a unique user ID for each viewer - Recommended token validity is
  10h-20h
</Note>

Then use the token to embed the video:

```typescript theme={null}
const privateEmbed = video.getPrivateEmbedPlaybackIframeCode({
	jwtToken: 'your-jwt-token',
})
console.log(privateEmbed.iframeHtml)
```

<Info>
  JWT signed embeds work from any domain, regardless of origin whitelisting
  settings. This makes private embeds more flexible than public embeds when it
  comes to domain restrictions.
</Info>

## Step 5: Controlling Video Playback

Once the video is embedded, you can control its playback programmatically using the `play()` and `pause()` methods.

```typescript theme={null}
import { FermionRecordedVideo } from '@fermion-app/sdk/recorded-video'

const video = new FermionRecordedVideo({
	videoId: 'your-video-id',
	websiteHostname: 'your-domain.fermion.app',
})

// Assuming you have added the iframe to your DOM
// For example:
// const embed = video.getPubliclyEmbedPlaybackIframeCode();
// document.getElementById('video-container').innerHTML = embed.iframeHtml;

// You can now control the video
video.play() // to play the video
video.pause() // to pause the video
```

<Info>
  The SDK automatically assigns a unique ID to the iframe when you use
  `getPubliclyEmbedPlaybackIframeCode` or `getPrivateEmbedPlaybackIframeCode`.
  This allows `play()` and `pause()` to find the iframe automatically without
  you passing the iframe element.
</Info>

If you have multiple videos or a custom iframe setup, you can pass the iframe element directly to the methods:

```typescript theme={null}
const iframeElement = document.querySelector('#my-custom-iframe-id')
video.play(iframeElement)
video.pause(iframeElement)
```

## Step 6: Add Event Listeners (Optional)

Track video playback events using the SDK's event system:

```typescript theme={null}
const video = new FermionRecordedVideo({
	videoId: 'your-video-id',
	websiteHostname: 'your-domain.fermion.app',
})

// Setup event listeners
const events = video.setupEventListenersOnVideo()

// Listen for video events
events.onVideoPlay((data) => {
	console.log('Video started playing at', data.durationAtInSeconds, 'seconds')
})

events.onVideoPaused((data) => {
	console.log('Video paused at', data.durationAtInSeconds, 'seconds')
})

events.onTimeUpdated((data) => {
	console.log('Current playback time:', data.currentTimeInSeconds, 'seconds')
})

events.onVideoEnded(() => {
	console.log('Video playback ended')
})

// When done, clean up the listeners
events.dispose()
```

<Warning>
  Event listeners only work when using the Fermion video player through
  `getPubliclyEmbedPlaybackIframeCode` or `getPrivateEmbedPlaybackIframeCode`.
  They are not available when using manual M3U8 playback.
</Warning>

## Advanced: Custom M3U8 Playback

For security, all Fermion videos are encrypted using AES-128 (clearkey) encryption. The Fermion video player, embedded via the iframe methods, handles the decryption process seamlessly. We highly recommend using the default Fermion player as it is robust, production-ready, and provides a user-friendly experience out of the box.

However, for advanced use cases where you need to integrate the video into your own custom video player (like HLS.js, Video.js, etc.), you can get the M3U8 playback URL. The `getM3U8PlaybackUrl` method fetches the M3U8 manifest, patches it with the necessary decryption key, and returns a blob URL that your player can use.

<Warning>
  DRM-protected videos can only be played using the Fermion iframe embed. The
  custom M3U8 playback method does not support DRM at this time.
</Warning>

```typescript theme={null}
const video = new FermionRecordedVideo({
	videoId: 'your-video-id',
	websiteHostname: 'your-domain.fermion.app',
})

// Get M3U8 playback URL
const m3u8Url = await video.getM3U8PlaybackUrl({
	origin: 'https://cdn-storage.fermion.app',
	m3u8Pathname: '/path/to/your/playlist.m3u8',
	decryptionKey: '6815d8748df5297181862d32',
	signedUrlSearchParams: '?verify=signature_here',
})

// Use this URL with your custom HLS player
```

<Note>
  To get the playback options (origin, m3u8Pathname, decryptionKey,
  signedUrlSearchParams), you need to call the
  `get-signed-url-data-for-recorded-video-playback` API endpoint from your
  backend server with your Fermion API key. Refer to [API
  Reference](/api-reference/video/get-signed-url-data-for-recorded-videos) for
  more information.
</Note>


# Introduction
Source: https://docs.fermion.app/recorded-videos/introduction

Learn how to upload and manage recorded videos on Fermion

Fermion offers **ad-free video streaming** with **enterprise-grade DRM**, **[AI transcription in 50+ languages](/recorded-videos/captions)**, **[video watermarking](/recorded-videos/video-watermark)**, and **unlimited storage**, all built natively into the platform. Unlike traditional hosting solutions that require complex setup or third-party integrations, Fermion gives you everything you need to manage, protect, and deliver premium video content at scale.

***

## Why Fermion?

Your content deserves better than being locked behind generic video players or third-party ads. With Fermion, every stream, recording, and playback is designed for **clarity, control, and security compliance**.

Enjoy instant uploads, built-in content security, and AI-powered tools that make your video library not just smarter, but global.

<Columns>
  <Card title="Enterprise DRM Protection" icon="lock" href="/recorded-videos/video-library#drm-protection">
    Protect your premium content from unauthorized downloads and screen captures. Fermion implements **hardware-level DRM**, **dynamic watermarking**, and **granular access controls** to ensure your content stays secure, even in high-traffic environments.
  </Card>

  <Card title="AI powered subtitles in 50+ Languages" icon="closed-captioning" href="/recorded-videos/captions">
    Reach audiences across the globe with **AI-powered subtitles**  that retains the language used inside the video. Automatically generate timestamped subtitles for global accessibility.
  </Card>

  <Card title="Embed Anywhere" icon="globe" href="/recorded-videos/embed-video">
    Add your videos directly into your LMS, course pages, or landing sites: fully **white-labelled**, hosted under **your brand domain**, with **custom colors**, **logos**, and **player controls**.
  </Card>

  <Card title="Ad-Free Playback" icon="film">
    Deliver a **pure viewing experience** with no third-party ads or interruptions. Your students focus entirely on your content
  </Card>
</Columns>

***

## Built for modern content delivery

Fermion’s streaming engine goes beyond simple video hosting. It handles **transcoding**, **DRM enforcement**, and **AI-driven analytics** automatically: no backend setup, no separate billing, no engineering dependency.\
Every uploaded video is **instantly processed into multiple resolutions** and made available with [captions](/recorded-videos/captions), DRM support and [video watermarking](/recorded-videos/video-watermark) .

Fermion’s focus is **education-grade reliability**, that is, your videos load faster, play smoother, and remain secure under all conditions.

***

## Upload and manage videos

You can upload and organize all your recorded videos directly inside the [Video Library](/recorded-videos/video-library) on your Fermion dashboard. The library serves as your central hub for managing course-related and standalone videos. You can also find the embed code for the videos here too. Learn more about how to [embed videos externally](/recorded-videos/embed-video)


# Troubleshooting Steps
Source: https://docs.fermion.app/recorded-videos/troubleshooting-playback

Comprehensive guide to resolve video playback problems on Fermion-powered platforms

If you're experiencing difficulties playing videos on a platform powered by Fermion, this guide will help you identify and resolve the issue. Follow these steps systematically to troubleshoot your video playback problems.

## Quick Diagnostic Checklist

Before diving into detailed solutions, run through this quick checklist:

* Is your device/browser modern and up-to-date?
* Are you using a supported browser?
* Is your internet connection stable?
* Have you tried refreshing the page?
* Are you accessing the video from the correct platform?

## Common Issues and Solutions

Please follow the steps below to resolve some common issues we see regarding video playback.

### Videos not playing due to outdated technology

* **DRM Videos**: If the video uses Digital Rights Management (DRM), ensure you're using a modern device and browser
* **Browser Updates**: Update your browser to the latest version
* **Recommended Browsers**:
  * Google Chrome (latest version)
  * Mozilla Firefox (latest version)
  * Safari (latest version)
  * Microsoft Edge (latest version)

**How to check your browser version**:

* **Chrome**: Click the three dots → Help → About Google Chrome
* **Firefox**: Click the hamburger menu → Help → About Firefox
* **Safari**: Click Safari → About Safari
* **Edge**: Click the three dots → Help and feedback → About Microsoft Edge

### Slow buffering, frequent pauses, or videos not loading

1. Visit [speed.cloudflare.com](https://speed.cloudflare.com)
2. Run the speed test
3. **Minimum Requirements**:
   * Download speed: 5 Mbps for standard quality
   * Download speed: 10+ Mbps for HD quality

* **Try a different network**: Switch to mobile hotspot or different WiFi
* **ISP Issues**: Sometimes your Internet Service Provider can create degraded performance with our CDNs
* **Router Reset**: Restart your router/modem

#### Clear Browser Cache and Cookies

1. **Chrome**: Settings → Privacy and security → Clear browsing data
2. **Firefox**: Options → Privacy & Security → Clear Data
3. **Safari**: Safari → Preferences → Privacy → Manage Website Data
4. **Edge**: Settings → Privacy, search, and services → Clear browsing data

#### Disable Browser Extensions

1. Open browser in incognito/private mode
2. If videos work in private mode, disable extensions one by one
3. Common problematic extensions: ad blockers, VPN extensions, security tools

### Network Configuration

* **Firewall Settings**: Ensure video streaming sites aren't blocked
* **Corporate Networks**: Some corporate networks block video streaming
* **VPN Issues**: Disable VPN if videos work without it
* **Proxy Settings**: Check if proxy is interfering with video delivery

## Still Having Issues?

If you've tried all the above solutions and are still experiencing problems, you have to contact support.

1. **Gather Information**:

   * Browser name and version
   * Operating system
   * Internet speed test results
   * Specific error messages
   * Steps you've already tried

2. **Platform Support**:
   * Contact the platform's support team
   * Provide detailed information about your issue
   * Include screenshots if possible

Once you have gathered the information, please reach out to your website administrator, and they will put you in touch with one of our platform engineers for further debugging.


# Video Library
Source: https://docs.fermion.app/recorded-videos/video-library

Learn how to manage and configure your videos on Fermion using the Video Library.

## Overview

The Video Library on Fermion is your central hub for managing all the [videos](/recorded-videos/introduction) uploaded to your platform. It allows you to organize, search, and maintain your video content efficiently. By providing a dedicated interface for video management, Fermion ensures that your content is easy to access, configure, and share with learners, making it easier to run courses, tutorials, or any video-based content.

Within the Video Library, you can upload new videos, create folders for organization, download them, and delete outdated or unnecessary content. Each video’s status, upload date, and available actions are clearly displayed, helping you maintain a clean and well-organized video repository.

<Check>
  Before you can access the video library, you have to enable it in the **Manage Features** section of your instructor dashboard sidebar. Learn more on how to [manage features](/manage-settings/manage-features)
</Check>

***

## Managing videos

You can manage videos as per your needs in video library. Each video entry provides quick actions for downloading, editing settings, or removing the video. Organizing videos into folders makes it easier to categorize them based on courses, topics, or content type.

<Steps>
  <Step title="Access the video library">
    From your instructor dashboard sidebar, navigate to the "Video Library" section. This is your central hub for all uploaded videos and folders.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_ckdAEvf3za.bwshgr.png)
  </Step>

  <Step title="Add new videos">
    Click the **"Add new videos"** button in the Video Library. Select a video file from your computer and upload it to the platform. Uploaded videos are automatically processed for playback compatibility. You can also enable AI transcription in video settings if desired.
  </Step>

  <Step title="Organize your videos">
    Create folders to categorize your content based on courses, topics, or content type. Click **"Create Folder"**, provide a descriptive name, and move videos into the folder for better organization.
  </Step>

  <Step title="Edit video settings">
    For any previously uploaded video, click the "Settings" option next to the video. Here you can update the thumbnail, configure whitelisted origins, enable public embeds, AI transcription, DRM protection, and get the embed code.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_EGKcQSK7os.dettfp.png)
  </Step>
</Steps>

***

## Video settings

Fermion allows you to configure individual settings for each video, ensuring they behave exactly how you want when shared, embedded, or played back by your learners. Video settings include thumbnail management, embedding restrictions, AI transcription, DRM protection, and public playback controls.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_pFogAYVjIS.wjgwhs.png)

### Thumbnail

A video thumbnail represents your content visually and is displayed when the video is shared or embedded. You can upload a custom thumbnail to make your video more appealing and recognizable to learners.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_rIFKIHn407.fyisad.png)

### Whitelisted origin and public embeds

You can specify a whitelisted origin, which restricts embedding of your video to specific domains. This adds an extra layer of security by ensuring that only your approved websites can embed your videos. If left empty, all origins can embed the video. Note that this setting does not affect playback when using JWT signed tokens.

Enabling public embeds makes the video playable by anyone without JWT authorization. This is useful for content that you want to share publicly or promote outside your platform.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_27kKkFYEpY.zxfqmh.png)

### Enable AI transcription

Fermion provides AI-powered transcription for your videos. By enabling this feature, captions are automatically generated and applied to your video, enhancing accessibility and engagement for your learners. Learn more about [AI powered captions](/recorded-videos/captions)

## DRM protection

Digital Rights Management (DRM) protection helps prevent unauthorized copying or distribution of your videos. Enabling DRM ensures your content is secure and only accessible to authorized users.

### Advanced Widevine configuration

Fermion supports **Widevine DRM** to ensure secure video playback across supported browsers and devices. Widevine allows content owners to protect videos from unauthorized access, copying, or redistribution while maintaining smooth playback for legitimate users.

Advanced configuration options let you fine-tune the security level and **HDCP (High-bandwidth Digital Content Protection)** settings for different video resolutions. These settings balance security and compatibility, depending on your audience and playback requirements.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_ULnzyqqoti.jkteju.png)

<AccordionGroup>
  <Accordion title="Understanding Widevine security levels">
    Widevine supports multiple security levels: **L1**, **L2**, and **L3**, based on how content decryption and processing are handled on the device:

    * **L1 (Hardware-secure)**: All content processing and cryptography happen within a trusted hardware environment (TEE). Provides the highest level of security, often required for HD and 4K playback.
    * **L2 (Partial hardware security)**: Decryption happens in hardware, but video processing occurs in software. Offers a balance between performance and security.
    * **L3 (Software-based)**: Decryption and processing both occur in software, making it the most compatible but least secure option. Ideal for lower-resolution playback or older devices.
  </Accordion>

  <Accordion title="Configuring HDCP protection">
    **HDCP** ensures that protected digital content is only transmitted over secure, encrypted connections (like HDMI or DisplayPort). You can configure HDCP for each resolution level:

    * **HDCP\_NONE (Widevine L3)**: No HDCP protection, allowing playback on all devices, including virtual and emulated environments.
    * **HDCP\_1.x or 2.x**: Stronger protection levels that restrict playback to compliant displays. Recommended for HD or premium content.
  </Accordion>

  <Accordion title="Applying settings by resolution">
    You can apply different security and HDCP levels based on video resolution and audio tracks:

    * **Audio**
    * **SD (360p / 480p)**
    * **HD (720p / 1080p)**
  </Accordion>

  <Accordion title="Balancing protection and compatibility">
    Higher security levels reduce the risk of content piracy but may limit playback on certain browsers or devices that lack hardware DRM support. For general educational content, **Widevine L3** is sufficient. For premium or licensed media, enabling **L1** and **HDCP** protection ensures stricter control over content access.
  </Accordion>
</AccordionGroup>

Learn more about [Widevine DRM](https://en.wikipedia.org/wiki/Widevine#Architecture)

### Download and embed

From the video settings, you can download the original file or get the embed iframe code to place your video on other pages or platforms. This makes sharing content simple while retaining full control over access and playback.

Navigate to the video settings and click the **"Download video"** button. Your original video file will be saved to your computer.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_mf9VRcZrF1.gogpez.png)

In the video settings, copy the iframe embed code. Paste this code on any web page or platform where you want your video to be displayed. Ensure you configure whitelisted origins or JWT tokens if required for security. Learn more about [embedding recorded videos](/recorded-videos/embed-video)

***

By leveraging the Video Library on Fermion, you can centralize all your video content, configure it for secure playback, and ensure your learners have the best viewing experience.


# In-Video Quiz
Source: https://docs.fermion.app/recorded-videos/video-quiz

Learn how to create interactive quizzes within course videos.

In-video quizzes allow instructors to make learning more engaging by embedding interactive questions directly within course videos. This helps maintain learner attention, reinforce key concepts, and assess understanding in real-time as students watch the content.

***

## How to add an in-video quiz

You can attach an in-video quiz to your videos easily with the help of the following steps:

<Steps>
  <Step title="Head over to the course builder">
    Head over to the courses section and open the course builder which is associateed with the video you want to attach the in-video quiz to.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_gYGSMHNpHx.lvtszw.png)
  </Step>

  <Step title="Navigate to the video">
    Head over to your **Courses** section in the instructor dashboard.\
    Open the course you want to edit and go to the **Syllabus** tab.
  </Step>

  <Step title="Edit the video">
    Click on the **three dots (⋮)** next to any video where you want to attach the quiz, then select **Edit**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/5m7SfNex1N.ektism.png)
  </Step>

  <Step title="Attach an in-video quiz">
    Click the **Add in-video quiz** button to attach an in-video quiz to this particular video.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_rdSALhOtwl.vuhvff.png)
  </Step>

  <Step title="Create a new quiz">
    Scroll to the **In-Video Quiz** section and click the **Create here to create a quiz** dialog box.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_kQmyAidka2.jxnmnt.png)
    Give your quiz a suitable title and click **Submit**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_iYt2ywuA54.zxncvn.png)
  </Step>

  <Step title="Create quiz questions">
    Click on the **Edit** button next to the quiz name and start creating questions for your quiz. You can also add a simple description for your in-video quiz.
    You can select **single correct** and **multiple correct** question types for your quiz, and then add the question label, available options, and the marking scheme .

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_f2nV9xXJtV.oiaqge.png)

    You can also choose to bulk import questions with the help of CSV. The CSV format details and rules are mentioned in the following accordion.

    <Accordion title="CSV Format Details">
      | **Column header**           | **Description**                                                                                                                         |
      | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
      | `questionTitle`             | A string representing the question title.                                                                                               |
      | `questionType`              | Must be either `single-correct` or `multi-correct`.                                                                                     |
      | `questionDescription`       | A string describing the question.                                                                                                       |
      | `correctOptionNumbers`      | Number(s) (1–8) indicating correct options (comma-separated). If `questionType` is `single-correct`, only one number should be present. |
      | `positiveMarks`             | Marks awarded for a correct answer.                                                                                                     |
      | `negativeMarks`             | Marks deducted for an incorrect answer.                                                                                                 |
      | `questionAnswerExplanation` | Explanation of the answer (optional).                                                                                                   |
      | `questionOption1`           | First answer option (required).                                                                                                         |
      | `questionOption2`           | Second answer option (optional).                                                                                                        |
      | `questionOption3`           | Third answer option (optional).                                                                                                         |
      | `questionOption4`           | Fourth answer option (optional).                                                                                                        |
      | `questionOption5`           | Fifth answer option (optional).                                                                                                         |
      | `questionOption6`           | Sixth answer option (optional).                                                                                                         |
      | `questionOption7`           | Seventh answer option (optional).                                                                                                       |
      | `questionOption8`           | Eighth answer option (optional).                                                                                                        |

      **Rules to Follow:**

      * All column headers are mandatory (fields marked *optional* may be left empty).
      * `questionType` must be either `single-correct` or `multi-correct`.
      * `correctOptionNumbers` must contain a number between **1–8** (comma-separated if multiple).
      * At least one of `questionOption1–8` must be filled.
      * Options referenced in `correctOptionNumbers` must not be empty.
      * For `single-correct` questions, only **one correct option number** is allowed.
    </Accordion>
  </Step>

  <Step title="Publish your quiz and select quiz time">
    After adding all your questions, click on **Save Changes** and come out of the quiz builder to the in-video quiz section. Here, click **Publish** to attach this quiz to the video. Click on **Change time** to edit when the quiz appears in the video playback.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_67KCJd3xfA.rrbapp.png)
  </Step>
</Steps>

Now, whenever a user plays this respective video, they will be prompted with an in-video quiz at the configured time.


# Video Watermarking
Source: https://docs.fermion.app/recorded-videos/video-watermark

Learn how to protect your recorded videos using dynamic, viewer-specific watermarks on Fermion.

Fermion’s **video watermarking** feature helps you safeguard your premium content from unauthorized screen recording and sharing. Every viewer sees a unique, moving watermark containing their personal identifiers, such as name or email, making content leaks easily traceable.

***

## Enable Watermarking

To activate watermarking for all your recorded videos:

<Steps>
  <Step title="Go to Recorded Video Settings">
    Navigate to **Dashboard → Settings → School Settings → Recorded Video Settings** to access watermarking options.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/chrome_Qu8pMQXL48.jkczlu.png)
  </Step>

  <Step title="Enable Video Watermarking">
    Toggle **Enable Video Watermarking** to activate watermark protection across all recorded videos on your school account.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/03-11-2025/i9bY0DElwL.vmdbpw.png)
  </Step>

  <Step title="Customize Appearance">
    Adjust the **Font Size (px)** and **Opacity (%)** to control how prominently the watermark appears during playback.
  </Step>

  <Step title="Select Identifiers">
    Choose which viewer identifiers should appear in the watermark:

    * Name
    * Email Address
    * Phone Number
    * User ID
  </Step>

  <Step title="Preview and Save Settings">
    Review the **live preview** to confirm how your watermark will look, then click **Save Security Settings** to apply changes.
  </Step>
</Steps>

![toggle-watermarking](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-10-2025/Arc_U4cZJtU9lE.yldsrn.png)

***

## Example Preview

Below is a sample watermark applied with only **Name** and **User ID** enabled.

<Example>
  ![Watermark preview](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-09-2025/video-watermark.mqethn.png)
</Example>

***

<Card title="Next Step" icon="closed-captioning" href="/recorded-videos/captions">
  Add **AI-generated subtitles** to make your videos more accessible and multilingual.
</Card>


# AI tutor
Source: https://docs.fermion.app/setting-up-course/ai-tutor

Enable AI-powered assistance for your students with contextual help across quizzes, videos, and articles.

Empower your students with real-time, contextual assistance powered by AI! Fermion's **AI tutor** feature enables you to provide an intelligent copilot for your courses, giving learners immediate, context-aware support across quizzes, videos, and articles.

When enabled, the AI tutor appears as a copilot in the bottom-right corner of the student interface. This AI answers students' questions based on relevant course material, drawing from the following context sources:

* **Quiz**: Understands the quiz question and related concepts.
* **Article**: Reads the article content and supplementary materials.
* **Video**: Utilizes generated video captions and transcript.

The AI provides rich, targeted responses—boosting student learning and engagement.

## How to Enable AI tutor

To activate AI tutor for your course, follow these steps:

<Steps>
  <Step title="Open the Course Builder">
    Go to the **Instructor Dashboard** and select **Courses** from the sidebar.
    ![Courses](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-11-2025/Arc_v1hjZaHOIc.hitkut.png)
    Choose the course where you want to enable AI tutor, then click **Open Course Builder**.
    ![Open course](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-11-2025/Arc_rcJMJEM39H.eppseo.png)
  </Step>

  <Step title="Navigate to AI tutor settings">
    In the Course Builder, select **AI tutor** from the sidebar.
    ![aitutor](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-11-2025/Arc_fXvznOZCbq.lxaeeq.png)
  </Step>

  <Step title="Enable AI tutor">
    Toggle on **AI tutor** for the desired content types:

    * **Quiz**: Students get AI-powered hints, explanations, or help while attempting quizzes, using the quiz questions as context.
    * **Videos**: Students can ask questions about videos, and the AI uses captions/transcripts to help clarify concepts or summarize content. Make sure captions are turned on for your videos by following the steps [here](/recorded-videos/captions).
      Captions are an opt-in feature with dedicated pricing, which can be checked [here](https://fermion.app/pricing)
    * **Articles**: The AI answers questions with the full article text as context, helping students get clarifications as they read.

    You can enable AI tutor for any combination of these content types depending on your needs.
    ![enable](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-11-2025/Arc_D9P7h9Uoju.ysyklz.png)
  </Step>
</Steps>

> **Tip:** Enable the AI tutor only on the formats (quiz, video, or article) where you want students to receive AI-powered help.

## Student Experience

Once enabled, students see an AI copilot button on the bottom-right of the content screen. Clicking it opens a chat, where they can ask questions about the current quiz, video, or article.

* The AI uses the course data and current item (quiz, article, or video captions) as context to respond, making answers highly relevant.
* This feature helps students without needing to switch tabs or wait for instructor replies.

<AccordionGroup>
  <Accordion title="Can I enable AI tutor for only quizzes or videos?">
    Yes! It's entirely up to you whether to enable it for quizzes, videos, articles, or any combination. You can toggle each content type independently in the AI tutor settings.
  </Accordion>

  <Accordion title="Will the AI share course answers or help students cheat?">
    The AI is designed to assist and explain—not to give away answers. However, instructors should review settings and monitor usage as appropriate for your Quizzes.
  </Accordion>

  <Accordion title="Can I turn it off mid-course?">
    Absolutely. You can revisit the AI tutor settings in the Course Builder at any time and toggle it off for any content type.
  </Accordion>
</AccordionGroup>

***


# Announcements
Source: https://docs.fermion.app/setting-up-course/announcements

Send announcements to all students enrolled in your course directly from your course dashboard.

Announcements are a powerful way to communicate directly with all students enrolled in a course. Think of them as targeted [email campaigns](/marketing-tools/email-marketing): each announcement is sent to every student associated with the particular course. Whether you’re sharing important updates, notifying about new [videos](/recorded-videos/introduction), or promoting upcoming [live sessions](/live-classes/what-are-live-classes), announcements ensure that your students stay engaged and informed at every stage of their learning journey.

## Possibilities

With announcements, you can create personalized email campaigns tailored to your course audience. You can format your content using rich text, add links, emphasize key messages, and even include visuals to make your updates more engaging. Each announcement can be tracked and managed directly from your course builder, helping you maintain simple communication with your learners.

<Check>
  Fermion offers the following email limits in paid plans:

  * **Basic Plan:** 500 emails per month. \$1 per additional 1,000 emails.
  * **Pro Plan:** 3,000 emails per month. \$0.50 per additional 1,000 emails.

  Learn more about [Fermion pricing](https://fermion.app/pricing).
</Check>

## How to create an announcement campaign

You can create an announcement campaign in your course with the help of the following steps:

<Steps>
  <Step title="Open the course builder">
    Head over to the **Courses** section and open the **course builder** for the course you want to send an announcement for.
    ![Open Course builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/course%20builder%20open.pdcqad.png)
  </Step>

  <Step title="Access the announcement section">
    From the sidebar, select **Announcements** and click **Create new announcement** to start a new campaign.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_RGFnwb6RlD.xxtodc.png)
  </Step>

  <Step title="Create the announcement">
    Click the **Create new announcement** button to create a new announcement and then, click the **Edit** button next to your newly created announcement to begin customizing it.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_TS9RD51NFh.vfskqa.png)
  </Step>

  <Step title="Set up your sender">
    Before sending any emails, ensure that you have a **sender** created in your Fermion account. After creating a sender, link the sender in this section and your learners will receive emails from this sender account whenever an announcement is sent.
    [Learn more about setting up a sender](/marketing-tools/email-automation)
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_7HFDDa3hwz.adirxb.png)
  </Step>

  <Step title="Write the email">
    Add an **email subject** and compose your **content**.
    The content editor supports **rich text formatting**, so you can style your message, add links, and format sections to match your tone and branding.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/17-10-2025/chrome_AbvQLmmWBt.soblng.png)
  </Step>

  <Step title="Send the campaign">
    Once you’re done, click **Save changes**, **send test mail** to preview it, and then **start campaign** when you’re ready.
  </Step>
</Steps>

Announcements make it easy to keep students in the loop without needing external tools. Every update is sent directly through Fermion, ensuring reliability, consistency, and full control over how you communicate with your learners.

***

## Next steps

<Columns>
  <Card title="Course Analytics" href="/setting-up-course/course-analytics">
    Track performance metrics and understand how your students engage with your content.
  </Card>

  <Card title="Bundles" href="/setting-up-course/bundle">
    Combine multiple courses into a single purchase to increase enrollment and value.
  </Card>
</Columns>


# Assignments
Source: https://docs.fermion.app/setting-up-course/assignments

Learn how to create and manage assignments inside your Fermion courses.

Assignments are a crucial part of any [course](/setting-up-course/prerequisites). They help instructors evaluate learner progress, encourage hands-on practice, and reinforce understanding. A well-structured assignment bridges the gap between theory and application, allowing learners to demonstrate their knowledge in a practical and measurable way.

On Fermion, Assignments can be added as a dedicated section inside your course syllabus. They enable learners to upload and submit files, such as code, project reports, or documents, directly through the platform. Instructors can set deadlines, restrict file types for relevance or security, and review submissions directly from their dashboard. You can also grade assignments out of 10 and provide clear feedback for each student using remarks, making assessment seamless, transparent, and actionable.

## How to create an assignment

You can create an assignment inside a course with the help of the following steps:

<Steps>
  <Step title="Open the course builder">
    Go to the **Instructor Dashboard** and select **Courses** from the sidebar.
    Choose the course where you want to add an assignment, then click **Open Course Builder**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/open%20course%20builder.thzvjc.png)
  </Step>

  <Step title="Add assignment section">
    Navigate to the **Syllabus** tab.
    Find the section where you want to add the assignment and click **Add in this section**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/chrome_Z8BuAWLaeI.vtlybw.png)
    From the list of available content types, select **Upload assignment**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/selectuploadassignment.ulqmlq.png)
  </Step>

  <Step title="Edit assignment details">
    Once the assignment block appears, click the **three dots (⋮)** next to it and select **Edit**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/chrome_XaFm2jQnM5.swuwip.png)
  </Step>

  <Step title="Add assignment title and description">
    Now you can:

    * Add a **Title** for your assignment
    * Write a **Description** (rich text supported) for your assignment. You can include formatted text, links, and images.
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/14-10-2025/assignment%20title.vekmbo.png)
  </Step>

  <Step title="Configure assignment options">
    You can configure the following options when setting up assignments:

    <AccordionGroup>
      <Accordion title="Allow file uploads">
        If enabled, students can upload files as part of their submission. Turn this off if the assignment only involves written/text input questions.
      </Accordion>

      <Accordion title="Restrict file types for uploads">
        If enabled, you can specify which types of files students are allowed to upload. Leaving this off will allow any file type.
        **Supported file types:**

        * **ZIP (.zip)**
        * **RAR (.rar)**
        * **PDF (.pdf)**
        * **Word (.doc, .docx)**
        * **Text (.txt)**
        * **Markdown (.md)**
        * **Excel (.xls, .xlsx)**
        * **CSV (.csv)**
        * **JPEG (.jpg, .jpeg)**
        * **PNG (.png)**
        * **GIF (.gif)**
        * **Python (.py)**
        * **JavaScript (.js)**
        * **TypeScript (.ts)**
        * **JSON (.json)**
        * **MP3 (.mp3)**
        * **MP4 (.mp4)**
      </Accordion>

      <Accordion title="Allow multiple files">
        Allow students to upload more than one file in a single submission. This option is useful for assignments that require several documents, images, or project files.
      </Accordion>

      <Accordion title="Allow multiple submissions">
        Enable this to let students submit their assignment multiple times. Each attempt will be recorded separately for review and grading. Useful for iterative or stepwise assignments.
      </Accordion>

      <Accordion title="Allow text input questions">
        If enabled, you can add one or more open-ended questions to the assignment for students to answer directly in the submission form. Each text input question can be set to accept either freeform text or a URL as the response. This allows you to ask for written answers or require students to submit a link (such as to a portfolio, document, or project).
      </Accordion>
    </AccordionGroup>

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-01-2026/Arc_vuHcy7wYat.emrjgy.png)
  </Step>

  <Step title="Set due date and time">
    Click on **Select due date & time** to set a deadline for the assignment.
    Once selected, learners will see the due date clearly on their assignments
  </Step>

  <Step title="Save and review submissions">
    After configuring all settings, click **Save assignment**.
    Your assignment will now appear in the course syllabus.

    To view and manage the submissions, click the **Show All Submissions** button
  </Step>
</Steps>

***

## Review & grade assignment submissions

In the edit assignment section, you can view and manage all student submissions for your assignments by clicking the **Show all submissions** button.

For each submission, you can see:

* **Student name and email**
* **Submission timestamp** (when the assignment was submitted)
* **Uploaded files**: you can download any submitted file
* **Preview button**: shows you a preview of supported filetypes, directly inside Fermion, without needing to download files.

<Accordion title="Supported file types & extensions">
  Here's a list of supported file types your students can submit:

  * **Document**:
    * PDF (`.pdf`)
  * **Image**:
    * JPG (`.jpg`), JPEG (`.jpeg`), PNG (`.png`), GIF (`.gif`), WEBP (`.webp`), SVG (`.svg`)
  * **Audio**:
    * MP3 (`.mp3`), WAV (`.wav`), OGG (`.ogg`), M4A (`.m4a`), AAC (`.aac`), FLAC (`.flac`)
  * **Video**:
    * MP4 (`.mp4`), WEBM (`.webm`), OGV (`.ogv`), MOV (`.mov`), AVI (`.avi`), MKV (`.mkv`), FLV (`.flv`), WMV (`.wmv`)
</Accordion>

* **Grade status**: whether the assignment is graded or not

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_GiktmjX3ZG.gepqph.png)

You can also **grade submissions** directly from this page, add **remarks or feedback** for the student, and track all submissions in a table format. This allows you to efficiently review, evaluate, and provide feedback to your learners.

Additionally, you also have an option to upload files, along with grade and remarks ( evaluated copies of submitted pdfs, for example ) when grading an assignment :
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_OR2AZ3Y5Na.zusoke.png)

Which the student can see on their course, like so :
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/01-12-2025/Arc_IsGn3hENYj.jwjmnz.png)

***

## View all assignment submissions across all courses

<Steps>
  <Step title="Open your Instructor Dashboard">
    Navigate to your **Instructor Dashboard**. Here, you'll find an overview of your courses, analytics, and recent activity.
  </Step>

  <Step title="Locate the assignments widget">
    Look for the **New assignment submissions (last 30 days)** widget on your dashboard homepage.
    This widget lists recent assignment submissions from all your courses for quick reference.
  </Step>

  <Step title="Click on `View all`">
    In the widget, click the **View all** button. This will open a dedicated page where you can see all assignment submissions across every course you manage.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-12-2025/Arc_ymdZcpX0t6.fcznvs.png)
  </Step>

  <Step title="Filter and manage submissions">
    On the "View all" page, you can:

    * View all recent assignment submissions in one place
    * Filter submissions by graded / not graded status
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-12-2025/Arc_OuFXPPWLff.eezubn.png)
    * Click on any submission to review files, provide feedback, and grade
      ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/26-12-2025/Arc_6XusMSZ8TZ.oelxji.png)
    * Download or preview submitted files (for supported file types)
    * Grade the assignment with feedback & files if needed.

    This central view helps you efficiently keep track of submissions and streamline your grading workflow.
  </Step>
</Steps>

## Next steps

<Columns>
  <Card title="Track course analytics" href="/setting-up-course/course-analytics">
    Learn how to monitor student progress, view engagement metrics, and measure performance across your courses.
  </Card>

  <Card title="Set up completion certificates" href="/setting-up-course/completion-certificate">
    Discover how to create and issue certificates to learners automatically after they complete your course.
  </Card>
</Columns>


# Adding Course Files
Source: https://docs.fermion.app/setting-up-course/attachments

Step-by-step instructions for uploading, managing, and organizing course materials like videos, PDFs, and presentations.

For every course item you create, you can upload files as attachments that are visible to user for downloads. These files could be:

* PDF files
* CSV files
* Notes, downloadable items, etc.

To add an attachment to the course item, follow these steps:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/28-11-2024/screenshot-000172%402x.ulgfdb.png)

1. Click on the three dots for the course item you want to attach the resource on.
2. Click on `Attach a resource` button

![](https://creator-assets.codedamn.com/fermion-instructor/02-08-2024/instructor_66467ae8ada1f52e23942268/-jLImo9mXt8jGNLKK8yS0)

From the screen here, you will be able to upload multiple files.

Once you upload all the resources, on the user side, it would look like this:

![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/28-11-2024/screenshot-000173%402x.kcmrkw.png)


# Bulk Import Syllabus
Source: https://docs.fermion.app/setting-up-course/bulk-import-syllabus

Discover how to upload an entire syllabus at once using the platform's bulk import syllabus tools via CSV.

Fermion supports bulk importing syllabus into your course using CSV files. This can be handy if you have a lot of content and you want to quickly import it into your course.

<Steps>
  <Step title="Navigate to Courses">
    Go to the **Instructor dashboard** and click on **Courses**.

    ![Instructor dashboard courses](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_34eE20BeOe.echxge.png)
  </Step>

  <Step title="Select Your Course">
    Select the course for which you want to bulk import the syllabus.

    ![Select course](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_j1PWOEqdF6.grwydd.png)
  </Step>

  <Step title="Open Syllabus">
    Click on **Syllabus** from the course navigation.

    ![Click on Syllabus](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_4XxRj1pNhZ.xdzdni.png)
  </Step>

  <Step title="Click on Bulk Import from CSV">
    Select **Bulk import syllabus via CSV** from the available options.

    ![Bulk import syllabus via CSV](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_JHp3vvkdjh.vtglia.png)
  </Step>

  <Step title="Review CSV Format">
    Review the CSV format requirements or download a sample CSV file for reference. Use the format guide to build your course syllabus.

    ![CSV format and sample download](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_JGz6FYxofc.kxddac.png)

    <AccordionGroup>
      <Accordion title="Required CSV Columns">
        * **`itemType`** (required): The type of content item. Supported values:
          * `Article`
          * `Video`
          * `LiveEvent`
          * `IoCodingLab`
          * `InteractiveCodingLab`
        * **`itemTitle`** (required): The title of the item (string)
        * **`sectionName`** (required): The section name where the item belongs (string)
      </Accordion>

      <Accordion title="Optional CSV Columns">
        * **`itemDescription`** (optional): Description of the item (string)
        * **`liveSessionStartAt`** (optional, for `LiveEvent`): Date string for when the live session starts. Example: "January 31 2025 02:15:00 PM"
        * **`liveSessionHostsEmails`** (optional, for `LiveEvent`): Comma-separated list of host emails who can start the session
        * **`status`** (optional): Can be
          `Published` or `Draft`. If not specified,
          defaults to `Draft`
      </Accordion>
    </AccordionGroup>

    <Info>
      **Note:** LiveEvent (live class) items are only valid for cohort-based courses.
    </Info>
  </Step>

  <Step title="Upload CSV File">
    Click on the drop field or drag and drop your CSV file to upload it.

    ![Upload CSV file](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_ICoafFqPi1.bluskt.png)
  </Step>

  <Step title="Verify Preview">
    Review the items shown in the preview to ensure everything is correct before importing.

    ![Preview items](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/11-12-2025/Arc_aosPMXHuHQ.nikbtm.png)

    <Info>
      **Dependent Items:** Course items like labs and videos are 'Published' once you attach a video or lab to the course item. This applies in cases where you set the status as `Published` for those items.
    </Info>
  </Step>

  <Step title="Import Syllabus">
    Once you've verified the preview, click the **Import** button to complete the bulk import process.
  </Step>
</Steps>

<Warning>
  Please note that once imported, you can only edit the items via Syllabus manager. Bulk importer will only allow you to import items, not edit them.
</Warning>


# Bundles
Source: https://docs.fermion.app/setting-up-course/bundle

Learn how to create, customize, and manage Bundles that combine multiple products like courses, eBooks, and live events into a single offer.

## What are Bundles?

Bundles let you combine multiple digital products, including [courses](/setting-up-course/prerequisites), [eBooks](/digital-products/introduction), contests, [downloadable resources](/digital-products/downloadable-products), and [live events](/live-classes/what-are-live-classes) into a single package. They make it easy to offer more value to your learners while simplifying how you sell and manage your products.

You can use bundles to create a complete learning path, offer a discounted collection of premium courses, or launch a special promo pack. You can even use bundles to provide **All product access** to students. Everything is neatly presented under one landing page, giving students a way to explore and purchase everything they need.

***

## Create a Bundle

Every bundle comes with its own landing page, which acts as your storefront for that package.
This page showcases everything the bundle includes, [pricing](/setup-pricing/fixed-pricing-plan) of the bundle and a short description about it. This gives learners a clear idea of what they’ll gain access to.

<Steps>
  <Step title="Enable the Bundles feature">
    Before creating a bundle, you need to **manually enable the Bundles feature** from your admin dashboard.
    Learn more about how to [enable features](/onboarding/account-setup#step-2%3A-manage-features)

    1. Head over to **Manage Features**.
    2. Enable the toggle for **Bundles**.
  </Step>

  <Step title="Create a new Bundle">
    1. Navigate to **Bundles** in your sidebar.
    2. Click on **Create New Bundle**.
    3. You will be prompteed to add a name for your bundle.

    You can also use the **Open Product Builder** if you want to **edit an existing bundle**.

    ![Create new bundle](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/createnewbundle.osgafm.png)
  </Step>

  <Step title="Define your bundle's metadata">
    Once your bundle is created, click **Landing Page** from the sidebar.

    Add your:

    * **Product Title**
    * **Product Tagline**
    * **Thumbnail Image**

    #### Product enrollment validity

    Below the product **title**, **tagline**, and above the **thumbnail**, you can configure the **Enrollment Validity** for your bundle. This setting determines how long a student retains access to the products included in the bundle after enrollment.

    You can choose from the following validity options:

    * **Forever**:  lifetime access to the bundle
    * **1, 2, 3, or 6 months**
    * **1, 2, 3, 4, or 5 years**
    * **Custom (in hours)**: ideal for short-term trials, demos, or promotional bundles

    <Info>
      The selected validity applies to all items within the bundle.\
      Once the validity period ends, student access to the bundle’s contents will automatically expire.
    </Info>

    ![Bundle Metadata](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/bundlemetadata.pisiet.png)
  </Step>

  <Step title="Add Items to Your Bundle">
    You can add various product types to your bundle - including [**Courses**](/setting-up-course/prerequisites), [**eBooks**](/digital-products/introduction), [**Live Events**](/live-classes/what-are-live-classes), **Contests**, and **Downloadable Products**.

    There are three ways to add items:

    <AccordionGroup>
      <Accordion title="1. Custom Items">
        You can manually add specific items to your bundle.

        Step 1. Click on **Add Product** and the find the desired product you want to add to your bundle
        ![Add items](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/add%20singular%20item.dokczn.png)

        <Tip>You can also **bulk add** all products and later remove any items you don’t want.</Tip>

        **Example:**\
        I want to add an [**eBook**](/digital-products/introduction) to the bundle, head over to eBooks and click **Add Product to Bundle** button next to the eBook you want to add.

        ![Add custom items](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/addebooktobundle.etdana.png)

        Check this box "**Allow users to access items in any order?**" if you want learners to access all items freely in any order instead of completing them one by one serially.
      </Accordion>

      <Accordion title="2. All Product Access">
        This option gives access to **all existing products** within your organization.

        Once enabled, any student who enrolls in this bundle will automatically get access to every product currently available.
      </Accordion>

      <Accordion title="3. All Recorded Course Access">
        Automatically includes access to **all recorded courses**, including any future ones you publish.

        <Info>
          “All Recorded Course Access” ensures new recorded courses are instantly available to students who’ve already enrolled in the bundle.
        </Info>
      </Accordion>
    </AccordionGroup>
  </Step>

  <Step title="Publish your Bundle">
    Once your landing page and items are ready, click **Publish product** to make the bundle live. You can also move your landing page to **draft** to unpublish it while you make some changes.

    ![publish Bundle](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/publish%20bundle.bysrtp.png)
    And voilà, your bundle is now live! You can share it using the link provided right after publishing.
  </Step>
</Steps>

***

## Pricing & Coupon Codes

Pricing for bundles works **exactly like pricing for other product types** (such as [Courses](/setting-up-course/prerequisites) or [eBooks](/digital-products/introduction)).\
You can set fixed prices, discounted prices, and manage regional pricing if applicable.

[Learn how to set up pricing](/setup-pricing/fixed-pricing-plan)

You can also apply coupon codes to bundles, similar to other products.\
This allows you to offer limited-time deals or special access promotions.

[Learn how to create coupon codes](/setup-pricing/add-coupon-codes)

<Check>
  Coupons and pricing logic remain consistent across all product types for a unified experience.
</Check>

***

## Enrolling Students

Students can **purchase bundles directly** from the landing page.\
As an admin, you can also **manually enroll students** into a bundle, for example, for corporate access or complimentary offers.

Head over to the **Students** section in your product builder to manually import users

[Learn how to manually enroll students](/digital-products/enroll-students)

<Info>
  Manual enrollment gives instant access to all items within the bundle for that user.
</Info>

***

## Manage your bundle

Use this page to control how students enroll in your bundle and perform important management actions. Head over to the **Settings** tab in your product builde to access these options.

#### Enrollment Settings

Manage how students can access your bundle.

**Only allow admin to enroll students:**\
Check this box if you want **only admins** to enroll students in this bundle.

<Info>
  If enabled, students cannot purchase or enroll in the bundle on their own, even if the bundle is published and public.\
  Admins must manually enroll users.
</Info>

Click **Save Changes** after updating this setting.

![Management Settings](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/08-10-2025/bundlemanagementsettings.vgdzzl.png)

#### Management Actions

These are the important actions you can take to manage your bundle:

<Accordion title="Archive Bundle">
  Archived bundles remain in your system but are **hidden from public view**.

  * To archive a bundle, go to **Settings** →**Management Actions** → click **Archive Bundle**.
</Accordion>

<Accordion title="Delete Bundle Permanently">
  Deleted bundles are **permanently removed** and cannot be recovered.

  * To delete a bundle, go to **Bundle Settings** → click **Delete Bundle**.

  <Warning>
    Make sure you really want to delete a bundle, as this action is irreversible.
  </Warning>
</Accordion>

***

## Best Practices & Tips

* Use **Bundles** to promote **career tracks**, **certification paths**, or **seasonal offers**. You can also use bundles to provide **all product access**
* Use [**coupon codes**](/setup-pricing/add-coupon-codes) for limited-time promotions.
* Regularly **review bundle contents** to ensure they stay relevant.

Bundles are an excellent way to **increase learner engagement** with your courses, and **simplify product management**.\
By combining multiple offerings into one unified product, you create more value and streamline access for your students.

Start building your first bundle today and deliver a complete learning experience, all in one place at [Fermion](https://fermion.app/).

***


# Frequently Asked Questions
Source: https://docs.fermion.app/setting-up-course/common-faqs

Frequently asked questions regarding setting up a course

This document lists some of the frequently asked questions related to course toolings on Fermion.

<AccordionGroup>
  <Accordion title="What type of courses can I create on Fermion?">
    You can create a recorded course or a cohort-based course (bootcamp style). A recorded course does not have the functionality for live classes and has no fixed start or end date. Cohort-based courses have a fixed start date, end date, and include live classes inside the course.

    [Read more about courses →](/setting-up-course/prerequisites#what-is-a-cohort-based-course%3F)
  </Accordion>

  <Accordion title="Can I bundle multiple courses together?">
    Yes, you can create and sell multiple courses together on Fermion. Bundling courses allows you to sell them at a single price. You can also include other digital products like eBooks, contests, or live events in a bundle.

    [Read more about course bundles](/setting-up-course/bundle)
  </Accordion>

  <Accordion title="Can I sell access to my entire platform?">
    Yes, you can sell "all platform access" to your students with the help of [Bundles](/setting-up-course/bundle). It's similar to a Udemy subscription, where a student can access multiple courses under the same platform for a single payment.
  </Accordion>

  <Accordion title="What other products can I create on Fermion?">
    You can create and sell [eBooks](/digital-products/introduction), [course bundles](/setting-up-course/bundle), platform access, and more, all as part of Fermion's digital products.
  </Accordion>

  <Accordion title="Can I customise how my course landing page looks like?">
    Yes, you can customise how your landing page looks.

    [Read more about customisation](/custom-landing-pages/introduction)
  </Accordion>

  <Accordion title="Does Fermion provide a landing page template or do I have to custom-code it?">
    Fermion provides a default template for course and product landing pages. However, you can fully customise them if you wish.

    [Learn more about custom landing pages →](/custom-landing-pages/introduction)
  </Accordion>

  <Accordion title="Can I enable direct checkout links for my courses?">
    Yes, you can enable direct checkout links for your courses, allowing students to purchase directly. Learn more about [direct checkout links](/custom-landing-pages/checkout-page-direct-links)
  </Accordion>

  <Accordion title="Do I need to integrate any external tool to check course analytics?">
    No, you do not need any external tool. Fermion shares all student data in one place.

    [Read more about course analytics](/setting-up-course/course-analytics)
  </Accordion>

  <Accordion title="Do I need to add custom parameters to track student performance?">
    No, all student performance is tracked automatically. You can view every student’s performance under the `Students` tab inside your course.

    [Learn more about student performance](/setting-up-course/course-analytics)
  </Accordion>
</AccordionGroup>


# Completion Certificates
Source: https://docs.fermion.app/setting-up-course/completion-certificate

Set up automated certificates for learners upon course completion and customize their design and content.

Completion certificates provide a professional way to acknowledge and celebrate learner achievements in your courses. These digital certificates serve as formal recognition of course completion and can significantly boost learner motivation and engagement.

When learners complete your courses, they receive a personalized certificate that includes their name, course title, completion date, and a unique certificate ID for verification purposes. These certificates can be downloaded as PDF files, shared on social media platforms like LinkedIn, or printed for physical display.

You can enable certificates for:

* Recorded courses: issue when a student reaches a completion threshold (for example 100% or 80%).
* Cohort-based courses: issue after a specific date/time (for example cohort end date) regardless of per‑item completion tracking.
* Live sessions: issue after the live session ends.

## Enable certificates

<Steps>
  <Step title="Open course settings">
    Open any course and navigate to <b>Settings > Completion certificate</b>.
  </Step>

  <Step title="Enable certificates">
    Toggle <b>Enable certificate for this course</b>.

    <img alt="Enable certificate for this course" />
  </Step>

  <Step title="Choose certificate template and orientation">
    You can upload a custom HTML template or generate one using AI.<br />
    Additionally, you can manually choose the orientation of the certificate (landscape or portrait).

    <img alt="Certificate template and orientation" />
  </Step>

  <Step title="Set eligibility criteria for recorded courses">
    For <b>Recorded courses</b>, select the completion percentage at which a user becomes eligible for a certificate.

    <img alt="Completion percentage for certificate" />
  </Step>

  <Step title="Set certificate issue date for cohort-based courses">
    For <b>Cohort-based courses</b>, choose the date after which certificates will be granted to learners.

    <img alt="Certificate issue date" />
  </Step>

  <Step title="Save changes">
    Once you've configured your certificate settings, click <b>Save</b> to apply the changes.
  </Step>
</Steps>

## Certificate template (AI builder)

<Steps>
  <Step title="Open certificate settings">
    Open any course and navigate to <b>Settings > Completion certificate</b>.
  </Step>

  <Step title="Enable certificates">
    Toggle <b>Enable certificate for this course</b>.
  </Step>

  <Step title="Generate with AI">
    Click <b>Generate with AI</b> in the certificate settings. Use the AI chat to describe your preferred style or layout, and the system will automatically generate a professional certificate template for you.

    <br />

    <img alt="AI template" />
  </Step>

  <Step title="Edit the template source code (optional)">
    Edit the generated template’s source code directly to make any further changes or customizations as desired.

    <br />

    <img alt="Edit source code" />
  </Step>

  <Step title="Apply the certificate">
    Once your template is ready, click <b>Apply certificate to this product</b> to use the new certificate for your course or product.

    <br />

    <img alt="Apply certificate" />
  </Step>
</Steps>

<p>
  The builder automatically supports variables like recipient name, course title, issue date, and certificate ID, so your certificates are always personalized and ready for sharing or download.
</p>

### Supported variables

* `{{forCompletingWhatEntityName}}` – course or product title
* `{{userFullName}}` – certificate recipient name
* `{{issuedAtFormattedDate}}` – issuance date (formatted)
* `{{certificateId}}` – unique certificate ID (hash)


# Course Settings
Source: https://docs.fermion.app/setting-up-course/course-settings

Learn to manage and configure all your course settings including enrollment, certificates, refunds, and more.

Managing your course settings allows you to customize the way your course behaves for students, control enrollment, configure completion certificates, and fine-tune additional preferences. Below is a breakdown of the available settings and how to configure them.

Navigate to the **Settings** tab in your course builder to access these course settings

## Refund policy

Refund policy settings let you decide whether students can request a refund for your course. By default, refunds are disabled, and students cannot request them from their dashboard.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_GoNQqb5YQP.xnjily.png)

***

## Completion certificate

You can configure whether your course issues a **certificate of completion** and customize its design. Certificates can be automatically generated with AI or uploaded using a custom HTML template.
Learn more about [completion certificates](/setting-up-course/completion-certificate)
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_sMEPmAqmOs.yihupf.png)

***

## Rating reminder

Rating reminders allow you to send automatic emails to students asking them to rate your course. By default, the email is sent on the 10th day after a student’s enrollment.\
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_XKrHWBwfaZ.xfmhwa.png)

***

## Enrollment settings

Enrollment settings control how students can join your course. You can restrict enrollment so only admins can manually add students, or allow open enrollment for anyone.\
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_PbeVzELxh4.ezlauu.png)

***

## Additional settings

Additional settings let you customize course preferences such as recommended completion time. If you set a recommended time, students will receive a gentle nudge if they haven’t completed the course within that period. Leaving it blank disables the nudge.\
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_pesALDKVNB.zalavq.png)

***

## Course discussions

Course discussions allow students to comment on individual course items and interact with peers. Enabling discussions helps build a community and encourages collaborative learning.\
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_0pHle4SgYd.cffycl.png)

***

## Management actions

<AccordionGroup>
  <Accordion title="Clone this course">
    Cloning creates an exact copy of your course which you can edit independently.
    Use this to create a similar course without starting from scratch.
  </Accordion>

  <Accordion title="Archive course">
    Archiving hides the course from students but retains all content and settings.
    You can restore archived courses later if needed. Enrolled users can still access the course
  </Accordion>

  <Accordion title="Delete course permanently">
    This action permanently removes the course and all its content.
    This cannot be undone. Make sure you really want to delete it before confirming.
  </Accordion>
</AccordionGroup>

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_CLpuTqYDIe.rmjboy.png)

## Next steps

<Columns>
  <Card title="Course FAQs" href="/setting-up-course/common-faqs"> Learn more about frequently asked questions regarding course setup, management, and best practices</Card>

  <Card title="Pricing & Plans" href="/setup-pricing/fixed-pricing-plan">Check out course pricing options, plan features, and billing details for your courses </Card>
</Columns>


# CSV Report
Source: https://docs.fermion.app/setting-up-course/csv-report

Export comprehensive student enrollment and progress data as CSV files, including enrollment dates, course completion status, and detailed section-wise progress for assignments, ebooks, videos, and labs.

The CSV Report feature allows you to export detailed student enrollment and progress data in a structured CSV format, making it easy to analyze student performance, track completion rates, and generate custom reports using spreadsheet applications.

## How to access CSV Report

<Steps>
  <Step title="Navigate to Courses">
    Click on the `courses` tab from your instructor dashboard.
    ![step1](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_ki0uTdwbC8.yepsuj.png)
  </Step>

  <Step title="Select the course">
    Click on the course for which you want to export student data.
    ![step2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_IrEIbG0yCp.hiuiwj.png)
  </Step>

  <Step title="Open the Students tab">
    You will find the `students` tab in the left sidebar of the course page. Click on it to access student management.
    ![step3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_S34981YOnT.wxrpff.png)
  </Step>

  <Step title="Select Exported reports tab">
    Once you're inside the `students` tab, you'll see three tabs at the top: "Students", "Overall progress", and "Exported reports". Click on the `Exported reports` tab to access CSV export functionality.
    ![step4](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_GSCbwHNN4o.hhyguq.png)
  </Step>
</Steps>

## CSV Report Structure

The exported CSV file contains comprehensive student data organized into the following columns:

### Student Information

* **Student Name**: The student's full name or nickname
* **Student Email**: The student's registered email address
* **Student Phone**: The student's contact phone number (if available)
* **Enrollment Date**: The date when the student enrolled in the course
* **Last Active Date**: Timestamp of the student's last activity on the platform

### Course Completion Overview

* **Total Course Items**: Total number of course items (videos, assignments, labs, ebooks, etc.) in the course
* **Completed Course Items**: Number of course items the student has completed
* **Completion Percentage**: Overall course completion percentage calculated from completed vs. total items

### Section-wise Progress Details

The CSV report includes detailed progress information for each course item, organized by section. Each item follows a structured column naming format: `(Section X) [Y] ITEM_TYPE - DETAIL`, where:

* **X** represents the section number (e.g., Section 1, Section 2)
* **Y** represents the item type identifier (a numeric code that identifies the type of content)
* **ITEM\_TYPE** indicates the type of content (IO LAB, ASSIGNMENT, EBOOK, VIDEO, INTERACTIVE LAB)
* **DETAIL** specifies the type of information (Type, Completed, Score, Completed At, etc.)

<AccordionGroup>
  <Accordion title="IO Labs">
    <ul>
      <li><b>(Section X) \[Y] IO LAB - Type</b>: The type or category of the IO Lab</li>
      <li><b>(Section X) \[Y] IO LAB - Completed</b>: Completion status (Yes/No)</li>
      <li><b>(Section X) \[Y] IO LAB - Score</b>: The score obtained for the IO Lab</li>
      <li><b>(Section X) \[Y] IO LAB - Completed At</b>: Timestamp of when the IO Lab was completed</li>
    </ul>
  </Accordion>

  <Accordion title="Assignments">
    <ul>
      <li><b>(Section X) \[Y] ASSIGNMENT - Type</b>: The type or category of the Assignment</li>
      <li><b>(Section X) \[Y] ASSIGNMENT - Submitted</b>: Submission status (Yes/No)</li>
      <li><b>(Section X) \[Y] ASSIGNMENT - Marks</b>: The marks obtained for the Assignment</li>
      <li><b>(Section X) \[Y] ASSIGNMENT - Submitted At</b>: Timestamp of when the Assignment was submitted</li>
    </ul>
  </Accordion>

  <Accordion title="Ebooks">
    <ul>
      <li><b>(Section X) \[Y] EBOOK - Type</b>: The type or category of the Ebook</li>
      <li><b>(Section X) \[Y] EBOOK - Completed</b>: Completion status (Yes/No)</li>
      <li><b>(Section X) \[Y] EBOOK - Completed At</b>: Timestamp of when the Ebook was completed</li>
    </ul>
  </Accordion>

  <Accordion title="Videos">
    <ul>
      <li><b>(Section X) \[Y] VIDEO - Type</b>: The type or category of the Video</li>
      <li><b>(Section X) \[Y] VIDEO - Duration (seconds)</b>: The total duration of the video in seconds</li>
      <li><b>(Section X) \[Y] VIDEO - Completed</b>: Completion status (Yes/No)</li>
      <li><b>(Section X) \[Y] VIDEO - Completed At</b>: Timestamp of when the Video was completed</li>
    </ul>
  </Accordion>

  <Accordion title="Interactive Labs">
    <ul>
      <li><b>(Section X) \[Y] INTERACTIVE LAB - Type</b>: The type or category of the Interactive Lab</li>
      <li><b>(Section X) \[Y] INTERACTIVE LAB - Completed</b>: Completion status (Yes/No)</li>
      <li><b>(Section X) \[Y] INTERACTIVE LAB - Score</b>: The score obtained for the Interactive Lab</li>
      <li><b>(Section X) \[Y] INTERACTIVE LAB - Completed At</b>: Timestamp of when the Interactive Lab was completed</li>
    </ul>
  </Accordion>
</AccordionGroup>

## Understanding the Data

### Column Naming Convention

The section-wise columns use a consistent format that makes it easy to identify:

* Which section the item belongs to
* The item type identifier (numeric code)
* The type of content (Lab, Assignment, Ebook, Video, etc.)
* The specific metric being tracked (Type, Completed, Score, Duration, etc.)

### Data Values

* **Completion/Submission Status**:
  * **Yes**: The student has completed/submitted the item
  * **No**: The student has not completed/submitted the item

* **Scores and Marks**: Numeric values representing the student's performance on graded items

* **Duration**: For videos, this shows the total video length in seconds

* **Timestamps**: ISO format timestamps (e.g., "2025-11-05T11:55:13.021Z") indicating when an item was completed or submitted

* **Completion Percentage**: A calculated value showing overall course progress as a percentage


# Detailed Student Report
Source: https://docs.fermion.app/setting-up-course/detailed-student-report

Access comprehensive student analytics including performance metrics, engagement breakdown, activity timeline, and detailed course item completion status.

## How to access detailed student report

<Steps>
  <Step title="Navigate to Courses">
    Click on the `courses` tab from your instructor dashboard.
    ![step1](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_ki0uTdwbC8.yepsuj.png)
  </Step>

  <Step title="Select the course">
    Student analytics are unique for every course. Click on the course for which you want to check student analytics.
    ![step2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_IrEIbG0yCp.hiuiwj.png)
  </Step>

  <Step title="Open the Students tab">
    You will find the `students` tab in the left sidebar of the course page.
    ![step3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_S34981YOnT.wxrpff.png)
  </Step>

  <Step title="Select a student">
    Once you're inside the `students` tab, you will find a list of all students enrolled in the course. Click on any student to view their detailed analytics.
    ![step3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_NQcuHZvf6j.qljyml.png)
  </Step>

  <Step title="View detailed student report">
    The detailed student report dashboard will open, showing comprehensive analytics including summary metrics, content engagement breakdown, activity timeline, and course item completion status.
    ![Student Analytics Dashboard](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_4Eq1CKrTYP.bymbcd.png)
  </Step>
</Steps>

## Dashboard overview

The detailed student report dashboard is organized into several key sections:

### Summary metrics

At the top of the dashboard, you'll see key performance indicators:

* **Quiz average score**: Overall average percentage across all quizzes completed by the student
* **Assignments submitted**: Total number of assignments the student has submitted
* **Streak**: Current consecutive days the student has been active on the platform
  These metrics provide a quick snapshot of the student's engagement and performance.

![key-perf](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_WLb9LTpLb1.yespex.png)

### Student profile card

The student profile section displays essential contact and activity information:

* **Email address**: Student's registered email
* **Phone number**: Contact number (if available)
* **Last seen online**: Timestamp showing when the student was last active
* **Total video watched**: Total video content consumed with completion percentage

This information helps you understand the student's engagement level and provides contact details for outreach if needed.

<div>
  <img alt="profilecard" />
</div>

### Content engagement breakdown

This section shows completion rates by content type, displayed as horizontal progress bars:

* **Videos**: Total time watched and completion percentage
* **Quizzes**: Completion status and performance
* **Live events**: Attendance and participation
* **E-books**: Reading progress
* **Articles**: Completion status
* **Contests**: Participation and completion

This breakdown helps you identify which types of content the student engages with most and where they might need additional support.

![engagement breakdown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_ILK2Ol4Ggf.sawezh.png)

### Course items & activity

The "Course items & activity" table provides a clear summary of every piece of course content a student has interacted with, as well as their progress and engagement for each item. **Filter the table** by content type to focus on specific areas-choose from Articles, Contests, E-books, Live Events, Quizzes, or Videos.

For each course item, the table displays:

* **Item name:** The title of the course content.

* **Status:** Easily see if an item is:
  * <span>Completed</span> - the student has finished the item.
  * <span>Incomplete</span> - the item is in progress or only partially completed.
  * Not completed - the item hasn't been accessed.
  * Not attended - for live events that were missed.

* **Details and activity:** Depending on the content type, you'll see:
  * Videos: Time spent watching (e.g., "258 sec").
  * Quizzes: Scoring status (e.g., "Not scored").
  * Live events: Access links to session recordings or event information.

![item-wise-breakdown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_WPux41C3xt.gabffm.png)

This granular view allows you to identify exactly which course items students have completed, how much time they've spent on each, and where they might be struggling.

### Course progress

The course progress section provides an overview of the student's advancement:

* **Overall completion**: Visual progress bar showing percentage completed
* **Completed items**: Number of course items the student has finished
* **Remaining items**: Number of items still to be completed
* **Enrollment date**: When the student first enrolled in the course

This gives you a clear picture of how far along the student is in the course curriculum.

## Using the analytics

The detailed student report helps you:

* **Identify struggling students**: Spot students who have low completion rates or haven't engaged with key content
* **Recognize high performers**: Find students who are excelling and might benefit from advanced content
* **Track engagement patterns**: Understand when and how students interact with your course
* **Provide targeted support**: Use the data to reach out to students who need help with specific content types
* **Monitor progress**: Track individual student advancement through your course curriculum

By regularly reviewing these analytics, you can proactively support your students and improve course completion rates.

## Bulk reset progress for multiple students

You can reset course progress for multiple students at once from the Students tab. This is useful when you need to allow students to retake a course or reset their progress after course content updates.

<Steps>
  <Step title="Navigate to Students tab">
    Follow the steps above to navigate to the `students` tab in your course.
  </Step>

  <Step title="Select students">
    Use the checkboxes in the student table to select the students whose progress you want to reset. You can select individual students or use the header checkbox to select all students on the current page.
  </Step>

  <Step title="Open Actions menu">
    Click on the `Actions` dropdown button located in the top right corner of the Students tab, next to the "Export all enrolled users as CSV" button.
  </Step>

  <Step title="Reset course progress">
    From the Actions dropdown menu, select `Reset all course progress` to reset the progress for all selected students. This will clear all their course completion data, including
    ![select students](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_9EeiLMB7hE.epbvqk.png)
  </Step>

  <Step title="Confirm the action">
    Confirm the reset action when prompted. This action cannot be undone, so make sure you want to reset progress for the selected students.
    ![confirm](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_VMKfdvRm9I.lbetvp.png)
  </Step>
</Steps>


# Course Landing Page
Source: https://docs.fermion.app/setting-up-course/landing-page

Understand how to customize and optimize your course landing page to attract learners and provide key course information.

Now that you've selected a course to get started with, this is how your landing page manager screen will appear. The screenshot below shows an example of a CBC (Cohort-Based Course), but depending on your chosen course type, you'll see the corresponding interface.

![qz\_NGx3PejXWDIPmJB\_MJ](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/qz_NGx3PejXWDIPmJB_MJ)

Let's explore each section in detail

## Design your course metadata

![eMLzQQxRb-F4B3XOeF-Ly](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/22-10-2025/chrome_MOmik8kH6n.mdcixz.png)

Setting up your course metadata is the first essential step. This includes:

* Creating an engaging course title
* Writing a compelling tagline
* Designing an attractive thumbnail
* Adding a promotional or teaser video

### Course Enrollment Validity

You can set the enrollment validity for your course. For example, Forever means that learners will have access to the course content indefinitely after enrollment. Adjusting this setting allows you to control access duration for your students. You can also set up **custom** validity, where you will have to enter the number of hours learners should have access to the course after enrollment. Once this time expires, they will no longer be able to view the content.

### Course Created At

This field shows the date when the course was created (e.g., 30 Sep, 2025). Changing this date will reorder your course on the landing page as well as in your instructor dashboard. This can help highlight newer or updated courses to your audience.

All changes are saved automatically in real-time as you edit.

We'll discuss this in more detail later in this guide.

## Set course goals and outcomes

![52zq7tHMNzSQEhcfU-wJj](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/52zq7tHMNzSQEhcfU-wJj)

This section allows you to define clear learning objectives for your course.

Simply outline the skills and knowledge that students will gain upon completing your course. The image above provides examples for your reference.

Click "Add More" to include additional goals - you can add as many as needed to comprehensively cover your course outcomes.

## Set your cohort dates

**Note:** This section is only available when you've selected "Cohort-Based Course" during course creation.

![s78fyCnj2IHDW6Bfvm6Eq](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/s78fyCnj2IHDW6Bfvm6Eq)

Each cohort features clearly defined start and end dates, along with an enrollment deadline, ensuring a structured timeline for both instructors and students.

![c\_yK9DrOx\_22cez\_KiKH3](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/c_yK9DrOx_22cez_KiKH3)

Please note the numbered elements in the image above:

1. **Enrollment Deadline** - The final date when students can register for the course.
2. **Start Date** - The official beginning date of your course.
3. **End Date** - The final day of your course.

You have complete flexibility to customize these dates according to your course schedule and enrollment preferences.

## Set course description

![3LtlqYUDhSmk9-TDTRZS1](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/3LtlqYUDhSmk9-TDTRZS1)

We've designed a comprehensive solution for all your course setup needs, including a powerful editor for creating detailed and professional course descriptions with full markdown support.

You can make your description as comprehensive and detailed as needed to effectively communicate your course value.

## Set landing page FAQs

FAQs are an excellent way to address common questions and concerns that potential students may have.

![0F1nz4gQ5AgORDbcueR75](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/0F1nz4gQ5AgORDbcueR75)

You can add both questions and answers directly from your dashboard. All FAQs will be displayed at the bottom of your course landing page for easy access.

## Set landing page reviews

Fermion simplifies the process of showcasing reviews on your course landing page. You can create authentic reviews from scratch within the platform, giving you complete control over the content.

![ZyZ1FuGLe2dr9rbpDBS6G](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/ZyZ1FuGLe2dr9rbpDBS6G)

You can create comprehensive reviews by including:

1. Reviewer's name
2. Star rating
3. Detailed review content
4. Profile photo URL
5. Job title
6. Company or organization name

The best part? You can add unlimited reviews to build credibility and trust with potential students.

## Set sample certificate

![certificate-section-example](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_zRAq7i9j9c.mqfppv.png)

Showcase the **certificate of completion** that learners will receive after finishing your course.\
This feature helps students visualize the tangible outcome of their learning journey, motivating them to enroll.

You can upload a **sample certificate image** directly from your dashboard.

## Set landing page instructor

![instructor-section-example](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/15-10-2025/chrome_9H0yYQ84d2.vijskv.png)

The **Instructor Section** allows you to highlight the person behind the course - you!\
This section allows you to **choose which instructors appear on your course landing page**. This helps learners connect with the instructor and builds trust through authenticity and transparency.

## Manage syllabus

![8XhVyKDaZ7hPFnm\_Txr4W](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/8XhVyKDaZ7hPFnm_Txr4W)

This section allows you to manage your curriculum and define what you'll be teaching.

You can also control whether your syllabus appears on the landing page. Notice the checkbox in the screenshot above? Simply check it to display your syllabus, or uncheck it to hide it from the landing page.

Learn more about [Syllabus management](/setting-up-course/syllabus)

## Publish your landing page

Once you've completed your metadata setup, your course landing page is ready for publication.

![\_wWjl0At13qQrXIZLo3rx](https://creator-assets.codedamn.com/fermion-instructor/01-08-2024/instructor_66467ae8ada1f52e23942268/_wWjl0At13qQrXIZLo3rx)

After setting your preferred URL, simply publish your course. The access URL will appear in the same section once published, allowing you to view your live course landing page.

You can edit the page in real-time as needed. Your courses can exist in three states:

* **Draft:** Courses in draft state are only accessible to instructors.
* **Unlisted:** Unlisted courses can be accessed directly via link but won't appear on the homepage by default.
* **Published:** Published courses are publicly available and will be listed on the homepage.


# Overall Progress
Source: https://docs.fermion.app/setting-up-course/overall-progress

View course-level student progress analytics including enrollment metrics, content breakdown, and completion progress for each course item across all enrolled students.

The Overall Progress tab provides a comprehensive view of how all students are progressing through your course, helping you identify engagement patterns and content areas that may need attention.

## How to access Overall Progress

<Steps>
  <Step title="Navigate to Courses">
    Click on the `courses` tab from your instructor dashboard.
    ![step1](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_ki0uTdwbC8.yepsuj.png)
  </Step>

  <Step title="Select the course">
    Click on the course for which you want to view overall student progress analytics.
    ![step2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_IrEIbG0yCp.hiuiwj.png)
  </Step>

  <Step title="Open the Students tab">
    You will find the `students` tab in the left sidebar of the course page. Click on it to access student management.
    ![step3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_S34981YOnT.wxrpff.png)
  </Step>

  <Step title="Select Overall Progress tab">
    Once you're inside the `students` tab, you'll see three tabs at the top: "Students", "Overall progress", and "Exported reports". Click on the `Overall progress` tab to view course-level analytics.
    ![step4](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_LjdsgWyIyR.wkezre.png)
  </Step>
</Steps>

## Course content and completion progress

Below the summary metrics, you'll find a detailed table showing completion progress for each course item across all enrolled students. The table includes three columns:

### Course content

The first (leftmost) column shows a structured list of all items in your course, clearly grouped by their section. Each section is then expanded to display its included content—such as videos, articles, assignments, interactive labs, and more. This makes it easy to quickly scan everything that makes up your course curriculum.

![Course content column highlighted](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_fY5R6qXtZ8.ouatkl.png)

* Section names are shown as headings, with a collapsible or indented list of course items underneath.
* Common content types (e.g., quizzes, labs, videos, articles, assignments) are all listed, matching the course’s order and structure.
* Every listed item corresponds directly to a row in the completion/progress columns to its right.

### Completion progress

![progress](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/24-11-2025/Arc_FadZfFcepY.yllxpn.png)

The center column summarizes progress for each course item across all enrolled students, including:

* **Student count**: The number of students who have completed the item (displayed as "X students").
* **Completion percentage**: Displays as a percentage out of all active enrollments.
* **Progress bar**: A horizontal bar visually represents the current completion percentage for each item.
* **Change indicators**: If a shift has occurred since the previous measurement period, you’ll see either:
  * A percentage increase (e.g., "25.0% increase")
  * A percentage decrease/dropoff (e.g., "10.0% dropoff")
  * Or "No change" when completion remains the same

This visual makes it easy to spot which items have high engagement (high bars, high percentages) and which need attention (low bars, low percentages, or large drop-offs).

### Actions

The rightmost column offers context-aware action buttons:

* **View stats**: Shown for coding labs and interactive/IO lab items; opens a detailed statistics panel for that content item.
* **View all submissions**: Shown for assignments; opens a full list of all student submissions collected for that task.
* Actions only appear where relevant, so the interface stays uncluttered for standard videos, articles, or quizzes.

These columns work together so you can scan by section, instantly see engagement and completion, and drill into deeper analytics or individual submissions—all from one table.

## Using overall progress analytics

The Overall Progress view helps you:

* **Identify engagement patterns**: See which types of content (videos, articles, labs) students engage with most
* **Spot problematic content**: Identify course items with low completion rates or high dropoff rates
* **Track improvements**: Monitor completion changes over time with increase/decrease indicators
* **Optimize course structure**: Use completion data to reorganize or improve content that students struggle with
* **Make data-driven decisions**: Use metrics to decide which content types to add more of or modify

By regularly reviewing overall progress, you can proactively improve your course content and support student success.


# Getting Started
Source: https://docs.fermion.app/setting-up-course/prerequisites

A comprehensive guide to creating a new course, including defining course structure, modules, and initial setup steps.

Before we get started on creating your first technical course on Fermion, please make sure you have access to a fermion demo account, or you should have the fermion instructor setup mapped to your domain.

We can help you setup domain mapping on a subdomain, root domain or a path. If you do not have any account setup, please reach out to us at [support@codedamn.com](mailto:support@codedamn.com) and, we'll help you setup quickly.

## Login Access

Once your account is setup, you will receive a username, and a password for your unique school URL, make sure to take your login access credentials from the team to help you login into your dashboard.

## Dashboard View

Once you're all setup up and logged in, you will see such a dashboard on your screen:
![instructor dashboard](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/18-11-2024/18%E2%80%AFPM.nbcqlj.png)

## What is a Cohort Based Course?

On Fermion, you can choose to create Recorded Courses, Cohort-based Courses, even a Hybrid Course, Workshops and so much more, depending on which audience you wish to cater.

Think of cohorts as courses which have a start date and an end date. One key difference between a CBC and a Recorded Course is the addition of one key element "live class". CBCs by default are known to have live classes inside the course curriculum while recorded courses do not. CBCs thus, have a strict end date and a start date.

## What is a Recorded Course?

A recorded course is simply a collection of pre-recorded video course items along with other items such as coding labs, quizzes, articles, etc. Note that recorded courses do not have live sessions inside the curriculum.

<Tip>
  Courses can also be **added to Bundles** along with other products like [eBooks](/digital-products/introduction), [contests](/contests/introduction), [downloadable products](/digital-products/downloadable-products), or [live events](/live-classes/what-are-live-classes). Bundles allow you to sell multiple products together as a single packaged offer. Learn more about [Bundles](/setting-up-course/bundle)
</Tip>


# Syllabus Management
Source: https://docs.fermion.app/setting-up-course/syllabus

Learn to organize and manage your course syllabus including recorded videos, live classes, contest and quizzes, articles and more

## Sections and Sub-sections

A **section** is the foundational building block of your course syllabus on Fermion. Before you can add any content—whether it’s a recorded video, live class, quiz, article, or coding lab—you must first create at least one section within your course. Every course item must belong to a section.

Sections help structure your course content, making it logical and easy for students to navigate. For example, you might create sections such as "Introduction," "Core Concepts," "Practice Exercises," and "Final Assessment."

Each section can also be further divided using **sub-sections**. Sub-sections allow you to break content down into smaller, manageable parts, such as lessons, topics, or weeks within a module. This hierarchical organization makes it easier to design comprehensive learning paths and helps students track their progress.

Whether you're importing syllabus items in bulk or adding them individually, all course content lives inside sections and sub-sections. You can always rearrange, rename, or reorganize these sections to improve your course structure as it grows.

<Steps>
  <Step title="Click on 'Add Course Item'">
    ![Add course item](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_aJtxrWyl2O.qvkgft.png)
    Open your course syllabus and click <b>Add course item</b>.
  </Step>

  <Step title="Enter a Section Name">
    ![Enter section name](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_mvxLiAstGd.szxhhx.png)
    Provide a name for your new section.
  </Step>

  <Step title="Note: Each Section Starts with an Article by Default">
    ![Section with default article](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_Bvg1rSSeFs.ocidal.png)
    When you create a section, an article is automatically added as the first item.
  </Step>

  <Step title="Add More Items to This Section">
    ![Add in this section](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_MxUvZ6aTyw.mcearz.png)
    Click the <code>+ add in this section</code> button to add content.
  </Step>

  <Step title="Choose a Course Item or Add a Sub-section">
    ![Choose content type](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_tvdn7Wemk5.btbqcu.png)
    Select from the available <a href="/setting-up-course/syllabus#course-items">course items</a> or add a sub-section.
  </Step>

  <Step title="Publish Your Course Items">
    ![Publish course items](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_lXH0QAmfW2.royszv.png)
    When you're ready, publish your course items to make them live for students.
  </Step>
</Steps>

### Adding and Organizing Sections

A well-structured course starts with well-defined sections. Sections act as the main chapters or modules of your syllabus and help students navigate through your course with ease.

#### How to Add a New Section

To keep your course organized and easy to follow, consider breaking it into meaningful sections, such as "Getting Started," "Theory Lessons," or "Practice Activities." To add a new section:

1. **Navigate to Your Course Syllabus:** Open the syllabus page for your course.
2. **Click "Add Course Item":** Choose the option to add a new section.
3. **Name Your Section:** Enter a descriptive name that captures the content theme.

![Add new section](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_U5GukObFTs.rgagjc.png)

You can add as many sections as your course requires. This flexibility allows you to introduce new modules as your course grows or as you refine its flow based on student feedback.

***

### Creating Sub-sections for Finer Structure

Sub-sections allow you to break a section into smaller, digestible parts such as individual lessons, topics, or weeks. For example, within a section called "Module 1: Basics," you might create sub-sections for "Lesson 1: Introduction," "Lesson 2: Key Concepts," and so on.

To add a sub-section:

1. **Within Your Desired Section:** Locate the section where you want to add more detail.
2. **Click "Add Sub-section":** Use the corresponding button or menu in the section.
3. **Provide a Name:** Give your sub-section a specific, clear label that reflects its content.

![Add sub-section](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_RWY87HJvFw.rmaakr.png)

You can create as many sub-sections within each section as you need—perfect for breaking up longer modules or grouping related lessons together.

***

### How Sections and Sub-sections Appear to Students

Fermion presents your syllabus in a clean, expandable list so that students can quickly see what’s ahead and keep track of their learning journey. Sections are displayed as main headers, with sub-sections shown nested underneath. This tree-like structure promotes both clarity and easy navigation.

Here’s how a typical syllabus with sections and sub-sections will look to learners:

![Sections display](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_OEc2Ph5UNB.wlixfu.png)

This format encourages students to move through your course step-by-step, while still letting them jump to specific modules or lessons as needed. As an instructor, you have the flexibility to rearrange sections and sub-sections at any time if you need to refine your course structure.

<Tip>
  Review your course layout from the student’s point of view to make sure the progression feels natural and the organization is intuitive!
</Tip>

***

### Clone Sections to Other Courses

You can easily reuse the structure of your course by cloning sections into other courses that you manage. This is useful for duplicating module templates, onboarding content, or lesson structures without rebuilding them manually.

#### How to Clone a Section

<Steps>
  <Step title="Hover and Click the Clone Icon">
    Move your cursor over the section you want to duplicate and click the <strong>Clone</strong> icon.

    <img alt="Clone icon" />
  </Step>

  <Step title="Select Destination Courses">
    A pop-up will appear listing your available courses. These are courses where you can copy (clone) the selected section.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_p2DVY90vTx.suaszu.png)

    <br />

    <Tip icon="info">
      <strong>Note:</strong> You cannot clone sections containing <strong>live classes</strong> into courses that do not support live content.
    </Tip>
  </Step>

  <Step title="Choose Courses">
    Select one or more courses where you want to copy the section by clicking <strong>Select</strong> next to each course.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/19-12-2025/Arc_eBkWgW4JDj.iipuxb.png)
  </Step>

  <Step title="Confirm and Clone">
    Review your selections, then click <strong>Clone to courses</strong>. The chosen section (including all its sub-sections or items) will be added to every selected course.
  </Step>
</Steps>

<Tip>
  Cloning lets you quickly reuse module templates, lesson structures, or common onboarding sections across multiple courses without manual rewriting. Just remember that live class sections can only be cloned to other compatible live-enabled courses.
</Tip>

***

## Course Items

Click on any course item below to learn more about how to create and manage it:

<Columns>
  <Card title="Article" icon="file-text" href="/setting-up-course/syllabus/article">
    Add text-based content with rich formatting
  </Card>

  <Card title="Recorded video" icon="video" href="/setting-up-course/syllabus/recorded-video">
    Upload video lectures of any duration, including DRM protection
  </Card>

  <Card title="Live class" icon="users" href="/live-classes/setup-live-class">
    Schedule and conduct interactive live sessions with your students
  </Card>

  <Card title="Coding lab" icon="code" href="/creating-coding-labs/what-are-coding-labs">
    Hands-on coding exercises for DSA/Web development/Data science and more
  </Card>

  <Card title="Quiz" icon="star" href="/setting-up-course/syllabus/quiz">
    Test knowledge with multiple choice questions
  </Card>

  <Card title="Contest" icon="trophy" href="/contests/introduction">
    Timed assessment for students with built-in proctoring
  </Card>

  <Card title="Upload assignment" icon="upload" href="/setting-up-course/assignments">
    Let students submit files for review, grade it from the dashboard
  </Card>

  <Card title="eBook" icon="book" href="/digital-products/ebook-course">
    Add non-downloadable books with built-in browser reader
  </Card>

  <Card title="SCORM" icon="building" href="/setting-up-course/syllabus/scorm">
    Import SCORM-compliant learning packages
  </Card>

  <Card title="Iframe embed" icon="external-link" href="/setting-up-course/syllabus/iframe-embed">
    Embed external content from any website
  </Card>

  <Card title="Resources" icon="download" href="/setting-up-course/syllabus/resources">
    Add downloadable files and materials for students
  </Card>
</Columns>

## Modify Availability

`Modify Availability` is a feature to make your course items available on a specific date and a specific time. It's especially used for `Content Dripping`.

Content dropping is a method of releasing course materials to students at scheduled intervals rather than all at once. This approach helps maintain a structured learning path and prevents students from feeling overwhelmed by too much information at once. It also helps keep students engaged and ensures they are progressing through the course at a manageable pace.

If you want to adjust availability of course items:

* Step 1: Click on the three dots infront of the course item you wish to modify.
  ![guDiXneRt-pYVcd8BBvhX](https://creator-assets.codedamn.com/fermion-instructor/02-08-2024/instructor_66467ae8ada1f52e23942268/guDiXneRt-pYVcd8BBvhX)

* Step 2: Click on "Modify Availability"

* Step 3: Once you "Enable" the "Content Dripping" mode. You can selecte a date from which your course item will be made available.
  ![lCuI5qi5JETST3H2zipMz](https://creator-assets.codedamn.com/fermion-instructor/02-08-2024/instructor_66467ae8ada1f52e23942268/lCuI5qi5JETST3H2zipMz)

* Step 4: Click on `Save` and you're good to go.

###### Please make sure to publish all items to make them available to your students, your course items are in-draft by default and to make them available you will need to publish them.


# Article
Source: https://docs.fermion.app/setting-up-course/syllabus/article

Learn how to create and manage articles in your course syllabus

An article is a written piece of content that you can create within the course. It can include text, images, links, and other multimedia elements to explain concepts, provide instructions, or deliver information to students. Articles are ideal for detailed explanations, step-by-step guides, and reference material. The article editor provides you with a proper markdown support so you can make them beautiful!

## How do I create an article?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="expand-course-items" />
  </Step>

  <Step title="Add an Article item">
    Click on <code>Article</code>. This will add an article inside your chosen section.<br />

    <img alt="add-article-item" />
  </Step>

  <Step title="Edit the article">
    Click on the three dots of the new article (added as <code>Article: Untitled Course Item</code>) and select <code>Edit</code>.<br />

    <img alt="edit-article" />
  </Step>

  <Step title="Update the content">
    A new editor will now open where you can change the article title and start adding your content.<br />

    <img alt="article-editor" />
  </Step>
</Steps>


# Iframe Embed
Source: https://docs.fermion.app/setting-up-course/syllabus/iframe-embed

Learn how to embed external content using iframes in your course syllabus

An **Iframe Embed** allows you to embed external content from any website directly into your course. This feature enables you to integrate third-party tools, interactive content, or any web-based resources that complement your course material.

## How do I add an iframe embed?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="expand-course-items" />
  </Step>

  <Step title="Add an IFrame Embed item">
    Click on <code>IFrame Embed</code>. This will add an iframe embed item inside your chosen section.<br />

    <img alt="add-iframe-embed-item" />
  </Step>

  <Step title="Add title and URL">
    After adding, set a title and enter the URL you want to embed.<br />

    <img alt="add-title-url" />
  </Step>

  <Step title="(Optional) Use experimental YouTube player">
    If you are embedding a YouTube video, you can choose to use an experimental player for enhanced experience. This custom player removes all the YouTube branding and the redirects, recommendations and cards that are usually at the end of any YouTube video.<br />

    <img alt="experimental-youtube-player" />
  </Step>
</Steps>


# Quiz
Source: https://docs.fermion.app/setting-up-course/syllabus/quiz

Learn how to create and manage quizzes in your course syllabus

A quiz is an interactive assessment tool that you can use to test your students' knowledge and understanding of the course material. Quizzes can include multiple-choice questions, true/false questions, short answers, and other formats. They help reinforce learning and provide immediate feedback to students.

## How do I create a quiz?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="expand-course-items" />
  </Step>

  <Step title="Add a Quiz item">
    Click on <code>Quiz</code>. This will add a quiz inside your chosen section.<br />

    <img alt="add-quiz-item" />
  </Step>

  <Step title="Edit the quiz">
    Click on the three dots of the new quiz (added as <code>Quiz: Untitled quiz</code>) and select <code>Edit</code>.<br />

    <img alt="edit-quiz" />
  </Step>

  <Step title="Set up the quiz details">
    The quiz editor will open in a new tab. Here you can change the quiz title and add details. Make sure to save your changes.<br />

    <img alt="quiz-details" />
  </Step>

  <Step title="Add questions">
    Go to the <code>Questions</code> tab and click <code>Add a new question</code> to create your first quiz question.<br />

    <img alt="add-question" />
  </Step>

  <Step title="Configure question and options">
    After adding a new question, select its type, write the question, and enter multiple options. Mark the correct option(s) as needed.<br />

    <img alt="question-options" />
  </Step>

  <Step title="Add description or explanation (optional)">
    You may also include a <code>description</code> or <code>explanation</code> for the question.<br />

    <img alt="question-explanation" />
  </Step>

  <Step title="Save and repeat">
    Save your question. You can add multiple questions to a single quiz.<br />

    <img alt="save-question" />
  </Step>
</Steps>

## How do I see quiz results and student submissions?

To review student performance on quizzes, follow these steps:

<Steps>
  <Step title="Go to the Instructor Dashboard">
    Navigate to your **Instructor Dashboard** and open the course where you've added the quiz.
  </Step>

  <Step title="Open the Students tab">
    Inside your course dashboard, click on the <strong>Students</strong> tab in the sidebar. This tab shows you all enrolled learners.
  </Step>

  <Step title="Click on overall progress">
    Within the Students tab, click on <strong>Overall progress</strong>. Here, you'll get a snapshot of student completion and activity across all course items, including quizzes.
  </Step>

  <Step title="View quiz submissions">
    Locate the quiz you want to review. Next to the quiz name in the list, click on <strong>View submissions</strong>.<br />

    <img alt="Accessing quiz submissions in instructor dashboard" />
  </Step>

  <Step title="Use the submissions page to filter and find students">
    You will be taken to the quiz submissions page.<br />

    <img alt="Quiz submissions list with filters" />

    <br />

    Here you can:

    <ul>
      <li>See a list of all students.</li>
      <li>Filter the list by <strong>Attempted</strong> or <strong>Not Attempted</strong> to quickly find who has completed the quiz.</li>
    </ul>
  </Step>

  <Step title="Expand a student's submission for full details">
    Click on any student's name to expand their submission.<br />

    <img alt="Expanded quiz submission details" />

    <br />
  </Step>
</Steps>


# Recorded Video
Source: https://docs.fermion.app/setting-up-course/syllabus/recorded-video

Learn how to add and manage recorded videos in your course syllabus

A video is a pre-recorded visual and audio presentation that you can include in your course. Videos can be lectures, tutorials, demonstrations, or any other type of visual content that helps convey information effectively. Videos are engaging and can simplify complex topics through visual representation.

## How do I add videos?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="expand-course-items" />
  </Step>

  <Step title="Add a Video item">
    Click on <code>Video</code>. This will add a video inside your chosen section.<br />

    <img alt="add-video-item" />
  </Step>

  <Step title="Attach a video">
    Click on <code>Attach Video</code> in the newly added <code>Video: Untitled course item</code>.<br />

    <img alt="attach-video" />
  </Step>

  <Step title="Edit video details and add a video">
    A modal will appear where you can edit the title, add a description, and select <code>Add a video</code>.<br />

    <img alt="video-modal" />
  </Step>

  <Step title="Select or upload a video from your library">
    Click on <code>Add a video</code> to open your <a href="/recorded-videos/video-library">video library</a>. If there are no videos, use the <code>Upload videos</code> button to add videos in bulk.<br />

    <img alt="video-library" />
  </Step>

  <Step title="Process and link your video">
    After uploading, videos may take a few hours to process. Once processed, click <code>Link Video</code> to attach it to your course item.
  </Step>

  <Step title="Repeat as needed">
    You can add multiple pre-recorded videos within your course.
  </Step>
</Steps>

## Maximum watch time constraint

The Maximum Watch Time Constraint feature sets a fixed time window for learners to complete watching a recorded video once they begin playback. For example, if the limit is set to 60 minutes,
the learner must finish the video within that duration from the moment they start. After the allotted time expires, access to the video is automatically restricted. This feature is designed to encourage focused, distraction-free learning by ensuring that students watch the video in one sitting rather than pausing or revisiting it later.
![maximum-watch-time-constraint](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/chrome_2Lyfs79Pn5.naxgnt.png)


# Resources
Source: https://docs.fermion.app/setting-up-course/syllabus/resources

Learn how to add downloadable resources and materials in your course syllabus

**Resources** are downloadable files and materials that you can provide to your students as part of your course. Resources can include PDFs, documents, code files, templates, or any other downloadable content that supports student learning.

## How do I add resources?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="resources1" />
  </Step>

  <Step title="Add a Resources item">
    Click on <code>Resources</code>. This will add a resources item inside your section.<br />

    <img alt="resources2" />
  </Step>

  <Step title="Enter details">
    Enter a <code>Title</code> and <code>Label</code> for your resource.<br />

    <img alt="resources3" />
  </Step>

  <Step title="Edit and upload files">
    Click on the newly added <code>Resource</code> item to edit it and add files.<br />

    <img alt="resources4" />

    <br />

    From here, you can edit the Name, Label and also upload files:<br />

    <img alt="resources42" />
  </Step>

  <Step title="Save and publish">
    Save your changes and publish the item to make it available to students.
  </Step>
</Steps>


# SCORM
Source: https://docs.fermion.app/setting-up-course/syllabus/scorm

Learn how to add and manage SCORM packages in your course syllabus

SCORM (Sharable Content Object Reference Model) is a set of eLearning standards that enables course packages to run reliably across compatible learning platforms. If a package is SCORM-compliant, it can communicate progress, scores, and completion data with Fermion.

## Why should I add SCORM packages?

* Content reusability: Integrate existing SCORM content you own or source from third parties.
* Standardization: Use an industry standard so content behaves consistently across platforms.
* Enhanced learning materials: Complement articles, videos, live classes, and labs with interactive SCORM modules.

## How do I add a SCORM package?

<Steps>
  <Step title="Expand course items">
    Click the <code>+</code> button to expand the course items' view.<br />

    <img alt="expand-course-items" />
  </Step>

  <Step title="Add a SCORM item">
    Click on <code>SCORM</code>. This will add a SCORM item inside your section.<br />

    <img alt="add-scorm-item" />
  </Step>

  <Step title="Edit the SCORM item">
    Click on the three dots of the new SCORM item (added as <code>SCORM: SCORM file</code>) and select <code>Edit</code>.<br />

    <img alt="edit-scorm-item" />
  </Step>

  <Step title="Upload your SCORM ZIP">
    Click on <code>Drop your SCORM ZIP here to upload</code> to upload a SCORM-compliant ZIP file.<br />

    <img alt="upload-scorm-zip" />
  </Step>

  <Step title="Wait for processing">
    Wait for the SCORM file to be processed and ready.<br />

    <img alt="scorm-processing" />
  </Step>

  <Step title="Publish the SCORM item">
    Click on <code>Go back to all items</code>, then click on <code>Publish</code> next to the SCORM course item.<br />

    <img alt="go-back-to-items" />

    <br />

    <img alt="publish-scorm-item" />
  </Step>
</Steps>


# Adding and Using Tags in Courses and Course Items
Source: https://docs.fermion.app/setting-up-course/tags

Learn how to add, manage, and use tags in your course items so learners can easily filter content based on topics, difficulty, or custom labels.

Tags help instructors categorize and organize both their courses and course items more effectively. By assigning tags such as **“Web Development”, “DSA”, or “Design”** to an entire course, you can group related content and make it easier for learners to browse by category when visiting your school website.

Similarly, tags can be applied to individual course items like [videos](/recorded-videos/introduction), quizzes, or [assignments](/setting-up-course/assignments) to help students filter and find the most relevant materials. For example, you can label lessons by difficulty: **Easy, Medium, Hard**, or by topic: **Frontend, Backend, Databases**, allowing learners to quickly navigate through large course syllabi.

In the following sections, you will learn how we can apply tags to courses and individual course items.

***

## Applying tags to a course

Tags help categorize your courses so visitors can quickly find content by category when they browse your school website. You can apply tags to each course to improve discoverability and make it easier for new users to filter courses by topic or interest.

<Steps>
  <Step title="Go to Courses">
    Head over to the **Courses** page in your dashboard.
  </Step>

  <Step title="Add a tag">
    Click the **Add Tag** button next to the respective course.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_5RVJdkLQSk.gejhqh.png)
  </Step>

  <Step title="Add tag name">
    Add a suitable value for the tag name. Make sure to add the same tag name as other courses of same category so that all the items are grouped together.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_lMtx3S8Wpd.bljbua.png)
  </Step>

  <Step title="Make the tag public">
    Open the tag **Settings** by clicking on the tag label
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_CquWnd6KFL.yfoxih.png)
    Click **Make tag public**. This ensures the tag is displayed on your school website. You can also remove the tag from the course here.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_NoBj9sS7UD.ezokfh.png)
  </Step>

  <Step title="Attach the tag">
    Save your changes. The tag will now be attached to the course.
  </Step>
</Steps>

Once attached, visitors can search and filter courses by this tag on your school site, making it easier to find courses by category.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_7ZmihwaWCq.lenbsp.png)

## Applying tags to course items

Follow these steps to add or edit tags for any item in your course syllabus.

<Steps>
  <Step title="Open the course builder">
    Head over to the **Courses** section and open the **Product Builder** for the course you want to manage.
    ![Open Course builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/course%20builder%20open.pdcqad.png)
  </Step>

  <Step title="Access the syllabus section">
    Navigate to the **Syllabus** section of the course.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/27-10-2025/chrome_UtYdAyvMZf.vpylpm.png)
  </Step>

  <Step title="Manage tags for a course item">
    Click the **⋮** (three vertical dots) next to any course item and select **Manage Tags**.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/GHFywttWbH.zumlcv.png)
  </Step>

  <Step title="Use the manage tags panel">
    You’ll now see the **Manage Tags** panel, which lets you:

    * Add, or remove tags for this specific course item.
    * Create new tags and choose a color for each tag using the color picker or enter a custom hex code.
    * View a preview of how your tag will appear in the learner’s view.
    * You can also select from existing tags you have created before in that particular course. Just click on the previously created tag and it will be attached to your course item.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_V8b42t0Rsi.vzmkvg.png)
  </Step>

  <Step title="Save your changes">
    Once you’ve added or updated the tags, click **Save Changes**.\
    The new tags will now be associated with that specific course item and visible to learners.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/chrome_JVlw5ybGzH.vsnhwu.png)
  </Step>
</Steps>

***

### How learners can use tags for course items

From a learner’s perspective, tags make course navigation simpler and more intuitive by allowing students to easily **filter** by clicking on the tag and discover content based on their learning preferences or current progress.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/28-10-2025/QeRdeCBFjg.ilfrcz.png)
For example, if lessons are categorized by difficulty, learners can start with `Easy` lessons to build a strong foundation and then gradually move on to `Medium` or `Hard` tagged lessons as they advance through the course. Similarly, topic-based tags like `JavaScript`, `React`, or `Backend` let learners focus on areas that interest them the most.

By effectively using tags, instructors create a more personalized and accessible learning experience for everyone.


# Coupon Codes
Source: https://docs.fermion.app/setup-pricing/add-coupon-codes

Learn how to create, manage, and share coupon codes for your courses to offer discounts and promote enrollments on Fermion.

Coupon codes are a great way to promote your courses at a discounted price and get more students to enroll in your course. Fermion lets you create and manage coupon codes within your course flow, which you can easily share with your students.

You can either create a fixed amount coupon (for eg: ₹500 off) or you can create a discount percentage. In this documentation we'll talk about both the ways of creating a coupon code.

## Global Coupon Codes

Global coupon codes allow you to create school-level discounts that apply across all your products: including [courses](/setting-up-course/prerequisites), [bundles](/setting-up-course/bundle), and other digital offerings. Instead of creating separate coupons for each item, a global coupon code ensures that students can use a single code anywhere within your school.

To add a global coupon, simply create a new coupon and enable the **Mark the coupon as school coupon** toggle. Once the changes are saved, this setting makes your coupon a global coupon code, allowing it to be applied universally across your entire catalog of products. Learn how to create a coupon code in the next section.

## How to create a coupon code

<Steps>
  <Step title="Navigate to courses">
    From your dashboard, head over to the `courses tab`.
    ![Step 1](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_7n9LsbvRFc.bplqha.png)

    <Warning>
      If you are setting the coupon codes for course [bundles](/setting-up-course/bundle), [eBooks](/digital-products/introduction) or other
      [downloadable products](/digital-products/downloadable-products), head over to their respective tabs.
    </Warning>
  </Step>

  <Step title="Select the course">
    From the courses page, select the course for which you are creating the coupon codes and click on **Open course builder**.

    ![Step 2](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_Z8XTE8Wyhp.fpsmpb.png)
  </Step>

  <Step title="Head over to the Coupon codes tab">
    Select the **Coupon codes** tab from your course builder sidebar.

    ![Step 3](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_581mi7zQNI.ikiztn.png)
  </Step>

  <Step title="Create a new coupon">
    Click on **create new coupon** to create a new coupon code.

    ![Step 4](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_4jB6ELhVon.wljsrq.png)
  </Step>

  <Step title="Select a coupon type">
    Once you create a new coupon, you will see such a screen:

    ![](https://codedamn-website-assets.s3.us-east-1.amazonaws.com/uploads/19-11-2024/32%E2%80%AFAM.aiujah.png)

    You can choose to either select a "Fixed Amount Discount" or a "Percentage Discount"

    * **Fixed amount discount** is where you are giving a flat discount with your coupon code. For eg: on a course of ₹5000, you can add a fixed amount discount of ₹500, which makes the overall payable amount for user to be ₹4500 (excluding taxes). It is best to use to retain magic numbers on your pricing, and making the overall calculations easier for both the parties.

    * **Percentage discount** is where you can create a coupon code discounting a percentage number. For eg: you can create a 10% OFF coupon on your course priced at ₹100 which makes the overall payable amount for the user to be ₹90 (excluding taxes).
  </Step>

  <Step title="How to create a fixed amount coupon">
    Once you click on **Create new coupon**, click on **fixed amount discount** as shown below.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_sWZjnwCwR9.wxvmcf.png)

    You will now see a coupon builder like this:

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_6C1CF3Zt2t.emxhyc.png)

    <AccordionGroup>
      <Accordion title="Select a currency">
        Select a currency from the drop down list and enter the discount amount. This is the amount that will be discounted from the final price.
      </Accordion>

      <Accordion title="Add the coupon name">
        Next up, add the coupon name. Use underscores for spacing.
      </Accordion>

      <Accordion title="Write a one-line message">
        You can also write a one-line message. This message will appear as soon as the discount code is applied.
      </Accordion>

      <Accordion title="Set an expiry date">
        Set an expiry date for the coupon. The coupon will automatically stop working post this date. In case you do not want the coupon to expire, simply toggle the `Infinite expiry?` button.
      </Accordion>

      <Accordion title="Set the coupon redeemable count">
        Set the coupon redeemable count. This determines how many times the coupon should be availed by all users. For eg, if you set the count to be 10, then this coupon can be used 10 times and then it will automatically stop working. If you do not want any redeemable count, you can select the `Infinite Redeemable?` option and this coupon will then have an infinite redeemable count.
      </Accordion>

      <Accordion title="Global coupon codes (School-level coupons)">
        A school-level coupon is applicable to **all products**, allowing you to offer a universal discount that can be used across your courses, bundles, or other digital offerings.
      </Accordion>
    </AccordionGroup>

    Click on **Create Coupon** to create the coupon.
  </Step>

  <Step title="How to create a percentage discount coupon">
    Once you click on **Create new coupon**, click on **percentage discount** as shown below.

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_PcC0XrgMur.eshqwp.png)

    You will now see a coupon builder like this:

    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_vR9jG2S7qf.cnhfnp.png)

    <AccordionGroup>
      <Accordion title="Add the coupon name">
        First of all, add the coupon name. Use underscores for spacing.
      </Accordion>

      <Accordion title="Write a one-line message">
        Write a one-line message. This message will appear as soon as the discount code is applied.
      </Accordion>

      <Accordion title="Enter discount percentage off">
        Enter the "Discount percentage off". This field determines how much discount in percentage is offered to the students.
      </Accordion>

      <Accordion title="Set an expiry date">
        Set an expiry date for the coupon. The coupon will automatically stop working post this date. In case you do not want the coupon to expire, simply click on `Infinite expiry?` button.
      </Accordion>

      <Accordion title="Set the coupon redeemable count">
        Set the coupon redeemable count. This determines how many times the coupon should be availed by all users. For eg, if you set the count to be 10, then this coupon can be used 10 times and then it will automatically stop working. If you do not want any redeemable count, you can select the `Infinite Redeemable?` option and this coupon will then have an infinite redeemable count.
      </Accordion>

      <Accordion title="Global coupon codes (School-level coupons)">
        Mark the coupon as a school coupon.\
        A school-level coupon is applicable to **all products**, allowing you to offer a universal discount that can be used across your courses, bundles, or other digital offerings.
      </Accordion>
    </AccordionGroup>

    Click on **Create Coupon** to create the coupon.
  </Step>
</Steps>

## How to share coupon codes with your students?

Once you have created the coupon code, you will find it in the coupon list. Here you can view all of the product level coupons and global coupon codes. You can also check the status, expiry and the redemption count of the coupon as well.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_V3FJFABdhT.zbznnz.png)

You can now copy the coupon code link, you can also edit the coupon details and deactivate the coupon from the same section.

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_SJ6AwghNj2.hqyose.png)

Simply click on the copy button to copy the coupon link and share it with your students. Now the students will be able to use the coupon code directly at the time of checkout and avail discounts.
![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/29-10-2025/chrome_6qMwqTIEoL.hnnmcd.png)


# Custom Checkout Fields
Source: https://docs.fermion.app/setup-pricing/checkout-fields

Learn how to collect additional customer information during checkout by creating custom fields for your courses, enhancing the purchasing experience and gathering useful data.

## Introduction

Custom Checkout Fields is a powerful feature in Fermion that allows instructors and course creators to collect additional information from learners during the checkout process. By default, the checkout form captures basic details such as name, email and phone number, but there are often situations where you need more specific data to personalize your sales process or gather insights from your students. With custom fields, you can now ask for extra information, such as student preferences, organizational details, prior experience, or any other information relevant to your course or program.
![CheckOut Fields](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Finalexample%20checkout.ewclpz.png)

## How Custom Checkout Fields Work

Custom Checkout Fields allow you to define additional input points on your checkout form. Currently, Fermion supports two types of fields:

1. **Text Input** – Allows users to enter free-form text, suitable for names, IDs, or short responses.
2. **Dropdown** – Provides a predefined list of options for the user to select from, ensuring standardized data collection for specific questions.

![text and dropdown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/text%20and%20dropdown.zmpars.png)

Each field can be configured with a label that appears to the learner, an optional description for additional context or instructions, and a setting to make the field required. You can also preview the field in real time to see how it will appear during checkout. This ensures that your form is clear, concise, and user-friendly before it goes live.

## Steps to Add Custom Checkout Fields

Before adding custom checkout fields, make sure you have added a pricing plan to the course. Learn more about [Fixed Pricing Plans](/setup-pricing/fixed-pricing-plan) and [Partial Payment Pricing plans](/setup-pricing/setup-emi)

Follow these steps to add custom fields to your checkout forms:

1. **Navigate to Courses**\
   Log in to your Fermion instructor account and go to the **Courses** section from your dashboard.

2. **Open Course Builder**\
   Select the course for which you want to add custom checkout fields and click on **Open Course Builder**.

   ![Open Course builder](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/course%20builder%20open.pdcqad.png)

3. **Go to Pricing**\
   In the left sidebar of the Course Builder, click on **Pricing** to manage your course plans.

   ![Navigate to pricing](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/navigate%20to%20pricing.jfmage.png)

4. **Select a Published Plan or Create a new one**\
   From the list of available plans, select the published plan to which you want to attach the custom checkout field. If no plan is created, you should create a new pricing plan. Learn more on how to create [Pricing Plans](/setup-pricing/fixed-pricing-plan)
   ![New Plan](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Create%20new%20pricing.vramoy.png)

5. **Locate Custom Checkout Fields**\
   Scroll down the plan settings until you find the **Custom Checkout Fields** section. Click on the **Add Field** button.

   ![Add custom checkout field](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Add%20field.ctxioz.png)

6. **Configure a Text Input Field**\
   If you are adding a **Text Input** field:
   * Select the **Text Input** option for the field type.
   * Enter a descriptive label that will appear to learners during checkout.
   * Optionally, provide a description to give additional instructions or context for the user.
   * Check the "Mark this field as required" box to make the field required if learners must fill it out to complete checkout.
   * Preview the field in the modal to see how it will appear to learners.

7. **Configure a Dropdown Field**\
   If you are adding a **Dropdown** field:

   * Select the **Dropdown** option for the field type.
   * Enter a label that will appear to learners during checkout.
   * Optionally, add a description to guide the learner.
   * Enter the predefined list of options that learners can choose from.
   * Check the box to make the field required if learners must select an option to proceed.
   * Preview the dropdown field to see how it will appear during checkout.

   ![Dropdown](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/add%20custom%20field%20dropdown.itqske.png)

8. **Add Field**\
   Once satisfied with your configuration and preview, click **Add Field** to apply the custom checkout field to your plan. Learners purchasing this plan will now see the field and provide the requested information during checkout.

## Custom Checkout Field in Action

Here is an example of how a text input custom field looks in the checkout form for your learners. You can see the field label, optional description, and how a required field appears to the user during checkout.

![Custom Checkout Field Example](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/Finalexample%20checkout.ewclpz.png)

## Accessing Custom Checkout Data

Once your learners start providing information through custom checkout fields, you can access this data in two ways:

### Export via Pricing Section

You can directly export the collected data from your course plans:

1. Go to **Courses** and open the **Course Builder** for your desired course.
2. Navigate to the **Pricing** section in the left sidebar.

![Export CSV Sales Data](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/06-10-2025/chrome_n4AU2DESAI.mvzhvr.png)

3. Inside the **Export Sales Data**, click on the **Export CSV** button
4. A CSV file containing all the sales data including student responses during checkout will be downloaded to your device.

### Access via Webhooks

For advanced integrations, Fermion allows you to access custom checkout data programmatically with the help of Fermion Webhooks. You can utilize the [Paid Digital Product Sale](/webhooks/event-payloads#4-paid-digital-product-sale) event to access the data. This way, every time a learner completes checkout, the data can be sent directly to your configured endpoint.

Learn more about setting up webhooks and handling custom checkout data in our [Webhooks Documentation](/webhooks/what-is-webhook).

***


# Frequently Asked Questions
Source: https://docs.fermion.app/setup-pricing/common-faqs

Frequently asked questions about Pricing Plans and related features on Fermion

This document lists some of the commonly asked FAQs related to setting product pricing and managing courses on Fermion.

<Accordion title="How many currencies can I support inside my course?">
  You can support your course in 180+ countries with 100+ currencies available for your pricing plan.
</Accordion>

<Accordion title="Do I need to integrate my own payment gateway on the platform?">
  No, you do not need to integrate your own payment gateway. Fermion handles and manages all payments and payouts for you. Learn more about this at [payment gateways](/setup-pricing/payment-gateway). For additional support regarding payment methods, [reach out to us](mailto:vishnupriya@fermion.app).
</Accordion>

<Accordion title="What payment gateways will be made available for my course?">
  We use Razorpay, PhonePe, and our in-house UPI solution for domestic payments (UPI, credit/debit cards, netbanking). For international purchases, gateways like Stripe and PayPal are available. Fermion’s in-house UPI solution reduces transaction costs to 0.5% compared to 2% on platforms like Razorpay. Learn more about [payment gateways](/setup-pricing/payment-gateway)
</Accordion>

<Accordion title="Can international users see their currencies in my course?">
  As long as you have supported their country's currency in your pricing plan, they can see it and purchase your product. You can also enable default fallback currencies.
</Accordion>

<Accordion title="Can I set up EMI based plans for my course?">
  Yes, you can build and set up custom EMI plans for your course. Learn more about setting EMIs on Fermion [here](/setup-pricing/setup-emi).
</Accordion>

<Accordion title="Do EMIs need to be configured with any bank?">
  No, EMIs do not need to be configured with any bank. Fermion handles and manages EMIs in-house.
</Accordion>

<Accordion title="How will students be notified of their next EMI payment?">
  Students receive timely reminders via email before each payment is due. If a payment is missed, access to the product is restricted.
</Accordion>

<Accordion title="What are custom checkout fields and how can I use them?">
  Custom checkout fields allow you to collect additional information from students during checkout. You can create text input or dropdown fields to capture data like graduation status, course preferences, or other relevant details. Learn more [here](/setup-pricing/checkout-fields).
</Accordion>

<Accordion title="How can I share my course with a direct checkout link?">
  Direct checkout links allow you to share a course or a pricing plan with students directly, bypassing the landing page. This is useful for emails and campaigns. Learn more [here](/custom-landing-pages/checkout-page-direct-links).
</Accordion>


# Custom payment gateway
Source: https://docs.fermion.app/setup-pricing/custom-payment-gateway

Learn how to integrate your own Razorpay or PhonePe account as a custom payment gateway on Fermion

If you already have a Razorpay or PhonePe account and prefer payments to be credited **directly to your own payment gateway account**, you can connect it as a custom payment gateway.

This gives you full control over your payment settings, reconciliation, and settlements, while Fermion continues to handle the student checkout flow and reporting.

<Info>
  If no custom payment gateway is enabled, Fermion's managed gateway will be active, and payments
  will be added to your Fermion balance for withdrawal via payouts. If custom payment gateway
  integration is enabled, student payments go directly to your payment gateway account.
</Info>

Fermion supports the following custom payment gateways:

<Columns>
  <Card title="Razorpay" href="/setup-pricing/custom-payment-gateway#custom-razorpay-integration">
    Integrate your own Razorpay account for INR payments via UPI, cards, and netbanking.
  </Card>

  <Card title="PhonePe" href="/setup-pricing/custom-payment-gateway#custom-phonepe-integration">
    Connect your PhonePe merchant account for seamless payment processing.
  </Card>
</Columns>

### Accessing payment gateways

To manage your payment gateways:

<Steps>
  <Step title="Navigate to Payment Gateways">
    Go to your **Instructor Dashboard → Payment Gateway** section in the sidebar. This is where
    you can view all available gateways, enable/disable them, and manage credentials.
  </Step>

  <Step title="Choose your gateway">
    Select the Razorpay or PhonePe gateway and click on **Show details** button to configure
    various settings. If no gateway is selected, Fermion managed gateways would automatically be
    active.
  </Step>
</Steps>

![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_4loMT0fi6M.dbabgd.png)

### Custom Razorpay integration

Razorpay is a widely trusted payment gateway in India, suitable for processing INR payments through UPI, credit/debit cards, and netbanking. It offers secure payment processing, instant notifications, and robust reporting tools for businesses of all sizes.

<Warning>
  Avoid switching back and forth between the custom Razorpay gateway. Disabling it after
  activation may cause payment failures and split payouts, complicating your finances.
</Warning>

You can enable Razorpay at Fermion with the help of the following steps:

<Steps>
  <Step title="Enable Razorpay">
    Toggle the switch to enable the gateway. Once enabled, it becomes active immediately for new
    orders.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_NesyKd3pPg.pslrvi.png)
  </Step>

  <Step title="Add Credentials">
    Enter your **Key ID** and **Key Secret** provided by Razorpay. These credentials ensure that
    payments are securely linked to your account. [Learn
    more](https://razorpay.com/docs/payments/dashboard/account-settings/api-keys/) on where to
    find these credentials.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Zx2AZASEF5.lsykjg.png)
  </Step>

  <Step title="Configure Webhook">
    Add the following **Webhook URL** provided in your Fermion Dashboard to your Razorpay
    account. [Learn more](https://razorpay.com/docs/webhooks/setup-edit-payments/) about how to
    add webhook URLs at Razorpay. Enable the following webhook event: - `payment.captured`
    Utilize the **Webhook Signing Secret** to verify webhook signatures. This ensures that
    Fermion receives real-time updates about payment status and avoids manual reconciliation.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/chrome_NesyKd3pPg.yawbso.png)
  </Step>

  <Step title="Add Razorpay to Fermion">
    Click on the **Update button** to add the Razorpay gateway to Fermion. Now you can receive
    payments from your learners with the help of Razorpay.
  </Step>
</Steps>

***

### Custom PhonePe integration

PhonePe is a leading payment gateway in India, ideal for processing INR payments through UPI, credit/debit cards, and wallets. It provides secure payment processing, instant notifications, and comprehensive merchant tools for businesses.

<Warning>
  Avoid switching back and forth between the custom PhonePe gateway. Disabling it after activation
  may cause payment failures and split payouts, complicating your finances.
</Warning>

You can enable PhonePe at Fermion with the help of the following steps:

<Steps>
  <Step title="Enable PhonePe">
    Toggle the switch to enable the gateway. Once enabled, it becomes active immediately for new
    orders.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-11-2025/screenshot-000618@2x.fejsmc.png)
  </Step>

  <Step title="Add Credentials">
    Enter your **Merchant ID** and **Salt Key** provided by PhonePe. These credentials ensure
    that payments are securely linked to your account. You can find these credentials in your
    PhonePe merchant dashboard.
    ![](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/16-11-2025/screenshot-000619@2x.lyiqzn.png)
  </Step>

  <Step title="Add PhonePe to Fermion">
    Click on the **Update button** to add the PhonePe gateway to Fermion. Now you can receive
    payments from your learners with the help of PhonePe.
  </Step>
</Steps>


# Custom Payment Links
Source: https://docs.fermion.app/setup-pricing/custom-payment-links

Generate one-time payment links for special sales or discounts and manually enroll users after payment.

Fermion allows instructors to generate custom payment links for special cases where you want to offer a one-time sale or provide a unique discount to a specific user. This is useful for personalized offers, negotiation-based deal closures, or handling payments outside of your standard course/catalog setup.

<Note>
  The custom payment links feature must be enabled first for your school. To learn how to activate it, refer [Manage Features](/manage-settings/manage-features).
</Note>

## How to Create a Custom Payment Link

<Steps>
  <Step title="Go to the custom payment links page">
    Go to your **Dashboard -> Payment links**.
    ![navigate to payment links](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_moaX2ooBHb.zztqeo.png)
  </Step>

  <Step title="Create a new payment link">
    ![create a new payment link](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_dtuV9C4IVh.bljtoa.jpg)
  </Step>

  <Step title="Fill in the details">
    1. From here, you can fill in :
       * Name for the payment link.
       * Add description and a thumbnail.
         ![details](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_w4D0jniCBh.ddyhvt.png)
  </Step>

  <Step title="Set up pricing">
    Now, you will have to manually set up a custom pricing plan , either [Fixed](/setup-pricing/fixed-pricing-plan) or [Partial](/setup-pricing/setup-emi)
    ![setup-pricing](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_6Wq01U0Olx.rujqdx.png)
  </Step>

  <Step title="Publish plan">
    Once you have added a pricing plan, make sure that the plan is in a `Published` state
    ![publish](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_9ANCMoCujV.asnbkc.png)
  </Step>

  <Step title="Share the payment link">
    After you are done setting up this custom payment option, go back to the `Link customization` page of this product and copy the custom payment link that can be shared with the users.
    ![share link](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/10-10-2025/Arc_rqIvpv6Ahk.ojzlhx.png)
  </Step>
</Steps>

<Warning>
  Once the user completes the payment via the link, **they are not automatically enrolled in your product or course**.You will need to manually enroll the user.
</Warning>

## Sales data for custom payment links

After creating a custom payment link, you can track all sales made through that link in the same link settings. Click on the sales button in the sidebar to get more information
This section lists all transactions associated with the link, including the name and the sales date. You can also **export the sales data** as a CSV file for reporting, bookkeeping, or compliance purposes.

## Coupon codes

Coupon codes work the same across the platform for all products, including custom payment links. You can combine custom payment links with coupon codes to give learners additional discounts.  To learn more about creating, managing, and applying coupon codes, head over to the [coupon codes documentation](/setup-pricing/add-coupon-codes).

## When should you use custom payment links?

* Providing a bespoke discount to a user by request
* Arranging payment for a bundle or product not directly listed on your site
* Solving for any manual or special arrangement outside your usual checkout flow

<Tip>
  Need to enroll the user? Follow the steps in [Manage users](/manage-settings/manage-users) to learn how to add someone to a product after they have paid.
</Tip>


# Fixed Pricing Plans
Source: https://docs.fermion.app/setup-pricing/fixed-pricing-plan

Learn how to create and manage fixed pricing plans for your courses or digital products.

Fermion lets you add and manage multiple pricing plans for your digital products. You can setup a fixed pricing plan, which requires a one-time payment from the students, or you can setup a partial payment plan for your students which works like a custom-EMI plan.

In this documentation we will learn how you can setup a fixed pricing plan for your courses or products.

<Warning>
  You can use the same flow to setup pricing for other products ([course bundles](/setting-up-course/bundle),
  [ebooks](/digital-products/introduction) etc). For simplicity, this documentation covers the setup flow for a course.
</Warning>

## How to setup a fixed pricing plan?

<Steps>
  <Step title="Go to the product and open Pricing">
    Head to any digital product in your school (let's use Courses as an example).

    <br />

    <img alt="Go-to-courses" />
  </Step>

  <Step title="Select the product">
    Select the specific course you'd like to set a pricing plan for.

    <img alt="Go-to-courses" />
  </Step>

  <Step title="Go to pricing">
    Once inside the course builder, click on the `Pricing` tab from the sidebar

    <img alt="Go-to-pricing" />
  </Step>

  <Step title="Select a new fixed pricing plan">
    <img alt="Go-to-pricing" />
  </Step>

  <Step title="Configure the fixed pricing plan">
    Click on the `fixed` plan option. This will expand the section and show multiple setup options.

    <img alt="fixed plan" />

    <ul>
      <li><b>Draft</b> – Plan is invisible to users. Edit and configure in this state.</li>
      <li><b>Unlisted</b> – Plan works but is not shown on your landing pages. You can open checkout via API.</li>
      <li><b>Published</b> – Plan is visible and purchasable by users.</li>
    </ul>
  </Step>

  <Step title="Add currencies and set prices">
    Click on <code>Select a currency</code> to pick the desired currency from the picker.<br />
    Enter the price or amount for the new currency.<br />
    Click on <b>Add a new currency</b> to add it to your plan.<br />

    <img alt="add-currency" />

    <img alt="currency-picker" />

    <img alt="enter-amount" />
  </Step>

  <Step title="Publish and save your plan">
    Click the <b>Plan state</b> dropdown and select <b>Published</b>.<br />

    <img alt="publish-plan" />

    <br />

    Finally, click <b>Save Changes</b> to publish your new plan.
  </Step>
</Steps>

<br />


# Built-in payment gateway
Source: https://docs.fermion.app/setup-pricing/payment-gateway

Learn how to use Fermion's built-in payment gateways.

Fermion offers the following payment gateways out of the box:

* Razorpay (Payments in INR)
* Bank UPI (Payments in INR)
* Stripe (All currencies supported)
* PayPal (PayPal eligible currencies supported)

Fermion-managed gateways simplify payments for you if you want instant setup without managing external payment accounts. Payments made through these gateways are automatically added to your **Fermion withdrawable balance**, from where you can [request payouts](/manage-settings/manage-payouts) anytime.

Students can pay using popular methods like **UPI apps, credit/debit cards, net banking, PayPal, etc.**. With instant verification and real-time updates, Fermion handles all the complexity of payment routing, settlement, and reconciliation for you.

## Transactions Cost

Fermion deducts **0% commission** on all sales made through the platform. Unlike other platforms, **we do not take any cut** from your transactions. All charges that apply are **levied by the upstream payment providers** and not by Fermion. Here is a rough charge estimate from gateways we support. This might change in future if payment gateways change their charges.

#### Current Transaction Charges

| Payment Method  | Fee by Provider                                | Notes                                            |
| --------------- | ---------------------------------------------- | ------------------------------------------------ |
| **Fermion UPI** | **0.5%** or **₹3 (whichever is higher)** + GST | Lowered rates via Fermion’s partnered bank       |
| **Razorpay**    | **2%** per transaction (+ GST)                 | Typical for cards, wallets, and UPI via Razorpay |
| **Stripe**      | 1-5% depending on currency                     | Stripe fee is applied directly                   |
| **PayPal**      | 4-8% depending on currency                     | PayPal fee is applied directly                   |

<Check>
  Fermion does **not** earn any commission from these fees. All charges are set and collected by
  banks or gateways directly.
</Check>

***

## Receiving payouts

Payouts are the transfers of your earned revenue from Fermion to your bank account. Whenever students purchase your courses or content, the collected payments are accumulated in your Fermion account balance.

Receiving payouts ensures that you get your earnings securely and on time. It's important to keep your payout details accurate so that funds are transferred without delays or errors. Getting paid with Fermion is simple and hassle-free. Once your bank account is added in Payout Details, you can request a payout directly from your dashboard.

Check the detailed guide here: [Receiving Payouts](/manage-settings/manage-payouts)


# Partial Payment Pricing Plans
Source: https://docs.fermion.app/setup-pricing/setup-emi

Learn how to set up and manage partial payment pricing plans for your courses or digital products, allowing students to pay in installments with flexible EMI options.

Fermion lets you add and manage multiple pricing plans for your digital products. You can setup a fixed pricing plan, which requires a one-time payment from the students, or you can setup a partial payment plan for your students which works like a custom-EMI plan.

In this documentation we will learn how you can setup a partial payment pricing plan for your courses or products.

<Warning>
  You can use the same flow to setup pricing for other products ([course bundles](/setting-up-course/bundle),
  [ebooks](/digital-products/introduction) etc). For simplicity, this documentation covers the setup flow for a course.
</Warning>

## What is a partial payment pricing plan?

Partial payment pricing plan is a type of pricing plan on Fermion where your students can pay you in installments instead of paying the entire amount in a single go.

After speaking with a lot of educators, we've realised that most of the students may not be able to afford course or product pricing, thus, you can setup a partial payment plan where you encourage your students to pay in installments.

You can also consider this as a custom-EMI plan since your students can pay you in installments. You can configure the EMI collection interval, minimum amount to pay, total cost and EMI options.

## Understanding terminologies

Before we figure out how to setup this pricing plan, there are a few things to understand. Let's go over them one by one:

* **Total cost of product:**

  This is the total price of your product or the final price the user will pay
  overall. All the EMIs you will be setting up should result as a sum equal to
  this number.

* **Minimum mandatory amount:**

  This is the mandatory amount that the user must pay upfront. User can pay
  more than this amount as well. Paying this amount will give user the access
  to product.

* **EMI collection interval:**

  You can set the interval in days, ie, when want the user to pay the next EMI
  if available.

## How does a partial payment plan work?

We've developed the core infrastructure to setup a custom-EMI based plan on products, at Fermion.

A partial payment plan or a custom EMI plan encourages students to pay the product fees in intervals.

<Warning>
  You can configure the entire installment plan as an instructor, including
  setting up the minimum amount to pay, the collection interval and the total EMIs
  required.
</Warning>

Let's understand this with an example. This is how a **4 installment plan** will work:

<u>
  Assume that the user pays the minimum mandatory amount: \$5 on November 19th,
  2024\. Then, their (4 installment) EMI plan becomes:
</u>

* Base payment of \$5 done on November 19th, 2024
* Installment #1 of \$1.25 to be paid on or before December 19th, 2024
* Installment #2 of \$1.25 to be paid on or before January 18th, 2025
* Installment #3 of \$1.25 to be paid on or before February 17th, 2025
* Installment #4 of \$1.25 to be paid on or before March 19th, 2025

## How to setup a partial payment pricing plan?

<Steps>
  <Step title="Head to the Courses tab">
    From your dashboard, go to the <b>Courses</b> tab.

    <br />

    <img alt="Step 1" />

    <Warning>
      If you are setting the price for course bundles, ebooks, or other digital products, head over to their respective tabs.
    </Warning>
  </Step>

  <Step title="Select the course">
    On the courses page, select the course for which you want to set up the partial payment (EMI) pricing plan.

    <br />

    <img alt="Step 2" />
  </Step>

  <Step title="Go to the Pricing tab">
    Click the <b>Pricing</b> tab from your course's landing page manager.

    <br />

    <img alt="Step 3" />
  </Step>

  <Step title="Select Partial Payment Plan">
    Click on the <b>Partial payment plan</b> option. This will expand additional configuration options.

    <br />

    <img alt="Step 4" />

    <ul>
      <li><b>Draft</b> state: Only you can see and edit the plan (not visible to students).</li>
      <li><b>Unlisted</b> state: Only accessible via direct API links, not shown on landing pages.</li>
      <li><b>Published</b> state: Functional and visible to students. Students can purchase via this plan.</li>
    </ul>
  </Step>

  <Step title="Configure the pricing plan">
    Set the following:

    <ul>
      <li><b>Total cost of the product</b> (overall price students will pay for the course)</li>
      <li><b>Minimum mandatory amount</b> (minimum upfront payment students must make to access the product; they can choose to pay more if they wish)</li>
      <li><b>EMI collection interval</b> (the number of days between required installment payments)</li>
    </ul>

    <br />

    <img alt="Step 5" />

    Default EMI options will be displayed based on your configuration. After setting these details, an installment plan will be auto-generated according to the user’s selection.

    <br />

    <img alt="Step 6" />

    <b>Example:</b>
    If a user opts for a 2-installment plan and pays the minimum mandatory amount (\$5 on November 19th, 2024), the schedule will be:

    <ul>
      <li>Base payment: $5 on November 19th, 2024</li> <li>Installment #1: $2.50 on or before December 19th, 2024</li>
      <li>Installment #2: \$2.50 on or before January 18th, 2025</li>
    </ul>

    If you want to create a custom installment (EMI) plan, click <b>Add another installment plan</b>.

    <br />

    <img alt="Step 7" />

    Specify the installment count.

    <br />

    <img alt="Step 8" />

    Your new plan will be displayed. Make sure to click <b>Save changes</b> to update.

    <br />

    <img alt="Step 9" />
  </Step>

  <Step title="Support multiple currencies">
    To allow your pricing plan to accept multiple currencies:

    <ul>
      <li>Click <b>Add a new currency</b>.</li>
      <li>Select the desired currency from the dropdown.</li>
      <li>Enter the price value in this currency.</li>
    </ul>

    <br />

    <img alt="Step 10" />

    <br />

    <img alt="Step 11" />

    After adding, click <b>Add currency</b>. Your new pricing will appear as shown:

    <br />

    <img alt="Step 12" />
  </Step>
</Steps>

## Direct checkout links for partial payment plans

Fermion also allows you to share your partial payment plans directly with students through **direct checkout links**. This is especially useful if you want to integrate your checkout with an external website, email campaign, or social media promotion. By using direct checkout links, students can access the payment page for a specific plan immediately, without navigating through your course landing page.

For a complete guide on setting up and using direct checkout links, please refer to our [Direct Checkout Links](/custom-landing-pages/checkout-page-direct-links).

<Info>
  All the available installment plans are shown to your students and they can
  select one which fits best for them.
</Info>


# Event Structure
Source: https://docs.fermion.app/webhooks/anatomy

Understand the structure of webhook events sent by Fermion.

Every webhook request sent by Fermion follows a **standard structure** to ensure consistency across all event types.\
This standardized format makes it easier for your server to reliably parse incoming events and handle them in a predictable manner.

By understanding the anatomy of a webhook event, you can:

* Log events for auditing purposes
* Avoid processing duplicates
* Correctly interpret the data for your workflows

Each webhook request contains the following core fields:

1. **`eventUniqueId`**\
   A globally unique identifier for the webhook event.\
   This ID helps you **track and log events reliably** and ensures that you do not process the same event multiple times, even if it is retried.

2. **`timestampIsoString`**\
   The timestamp when the event occurred, formatted in **ISO 8601**.\
   You can use this to **sort events chronologically**, monitor delays between occurrence and delivery, or detect potential latency issues in your processing system.

3. **`isTestEvent`**\
   A boolean value indicating whether the event is a **test event** triggered manually from the Fermion dashboard.\
   Test events are useful for **verifying your webhook endpoint** and making sure your server correctly handles the event payload before going live.

4. **`payload`**\
   Contains the actual event-specific data. The structure of this payload depends on the type of event you subscribed to.\
   Each event has its own fields, such as user information, course details, lab results, or video URLs. By processing the payload correctly, you can automate workflows and integrate with other systems seamlessly.

More information on payload for each event is provided in the next sections.

<Tip>
  Understanding this standard structure is the first step to building reliable integrations.\
  Always validate the webhook secret and log the `eventUniqueId` to avoid duplicates.
</Tip>


# Event Payloads
Source: https://docs.fermion.app/webhooks/event-payloads

Detailed breakdown of all webhook event payloads supported by Fermion.

Fermion webhook events include structured payloads to provide all necessary data for your integrations.\
Each payload is tailored to the specific event type, making it easy to automate workflows and handle events reliably.

Below is a detailed breakdown of each supported webhook event, including its trigger, TypeScript type, and description of the payload fields.

<Info>
  The Typscript type of a particular event can also be accessed when subscribing to the events
</Info>

***

## 1. Lab Run Tests

**Event Trigger:** When a user clicks the "Run Tests" button in a lab.

Fermion’s interactive coding labs are full-fledged environments that boot up quick and give learners
a near VSCode-like developer experience directly in the browser. These labs include an editor, terminal, preview window,
and dedicated challenge sections so students can learn by doing, not just by watching.

To gather more information about Coding Labs, you can navigate to [What are Coding Labs](/creating-coding-labs/what-are-coding-labs)

By integrating the Lab Run Tests webhook, you can capture when learners attempt or complete challenges,
track their progress, and feed the results into grading systems, analytics dashboards, or custom reporting tools.

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventLabRunTestsType = {
    eventUniqueId: string;
    timestampIsoString: string;
    isTestEvent: boolean;
    payload: {
      eventType: "lab-run-tests";
    } & {
      internalUserId: string;
      apiUserId: string | null;
      labId: string;
      challengeResult: {
        isLabAttempted: true;
        result: {
          challengeId: string;
          isChallengePassed: boolean;
          challengeLabel: string;
        }[];
      } | {
        isLabAttempted: false;
      };
    };
  }
  ```

  ### Payload Data:

  * `internalUserId` – Fermion’s internal user ID.
  * `apiUserId` – Your API-facing user ID (if available).
  * `labId` – Unique identifier for the lab run.
  * `challengeResult` – Contains lab results:
  * If `isLabAttempted`: `true`, result is an array of challenges with their IDs, pass status, and labels.
  * If `isLabAttempted`: `false`, no challenges were attempted.
</Accordion>

***

## 2. Live Event Session Caption Ready

**Event Trigger:** When captions for a live event session are ready.

Fermion automatically generates AI-powered captions for live sessions, synced with the video timeline to improve accessibility and inclusivity.
With this webhook, you can programmatically access the generated captions and integrate them into your workflows.

You can find more about captions for live events here: [Auto-recording & Captions for Live Sessions](/live-classes/recording-and-captions)

This webhook is useful for automated workflows like sending captions to students, embedding or processing with third-party translation tools.

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventLiveEventSessionCaptionReadyType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "live-event-session-caption-ready";
      } & {
          liveEventId: string;
          liveEventSessionId: string;
          captionEnglishDownloadUrl: string;
      };
  }
  ```

  **Payload Data:**

  * `liveEventId` – Unique ID of the live event.
  * `liveEventSessionId` – ID of the specific session.
  * `captionEnglishDownloadUrl` – URL to download the English captions.
</Accordion>

***

## 3. Live Event Session Processed MP4 Ready

**Event Trigger:** When a live event’s processed MP4 video is ready.

After a live session concludes, Fermion automatically generates a processed MP4 recording that can be accessed by students.
This ensures that learners who couldn’t attend live can still benefit from the session.

The recording typically takes a very short time to
process, depending on factors such as the duration of the session and the number of participants. As soon as the recording is processed,
this webhook event is triggered.

<Info>
  If you want students to be able to download the recordings of your lifestreams, you have to enable that feature in instructor dashboard.
  You can find out how to do that here: [Auto Recording](/live-classes/recording-and-captions)
</Info>

This webhook is useful for automating tasks like publishing recordings, delivering content to external systems, or archiving sessions for future use.

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventLiveEventSessionProcessedMp4ReadyType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "live-event-session-processed-mp4-ready";
      } & {
          liveEventId: string;
          liveEventSessionId: string;
          downloadUrl1080p: string;
      };
  }
  ```

  **Payload Data:**

  * `liveEventId` – Unique ID of the live event.
  * `liveEventSessionId` – ID of the session.
  * `downloadUrl1080p` – URL to download the processed video in 1080p resolution.
</Accordion>

***

## 4. Paid Digital Product Sale

**Event Trigger:** When a user purchases a paid product.

Fermion allows schools to sell a variety of digital products such as [E-books](/digital-products/introduction), [downloadable products](/digital-products/downloadable-products), premium resources, or add-on learning materials.
This webhook is fired whenever a student completes a purchase of a paid digital product.

you can use this event to sync sales data, trigger email confirmations, or update your accounting software.

<Accordion title="Payload Description">
  ```tsx theme={null}



  type FermionWebhookEventPaidDigitalProductSaleType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "paid-digital-product-sale";
      } & {
          userId: string;
          userFullname: string;
          userEmail: string | null;
          userPhoneNumber: string | null;
          paymentGateway: "Paypal" | "PhonePe" | "Razorpay" | "SelfRazorpay" | "Stripe" | "FermionUpi";
          chargedAmountInrPaise: number;
          productSlug: string;
          productName: string;
          additionalDataToCollectOnCheckoutResponses?: ({
              [x: string]: unknown;
          } | null) | undefined;
      };
  }

  ```

  **Payload Data:**

  * `userId`, `userFullname`, `userEmail`, `userPhoneNumber` – User details.
  * `paymentGateway` – Gateway used (e.g., FermionUpi, Paypal, Stripe, Razorpay).
  * `chargedAmountInrPaise` – Amount charged in paise (1 INR = 100 paise).
  * `productSlug`, `productName` – Identifiers for the purchased product.
  * `additionalDataToCollectOnCheckoutResponses` – This field contains any **custom data** you’ve chosen to collect from the user during checkout.\
    For example, if your checkout form asks for extra information like “Field of Study,” “Counsellor ID,” or other custom fields, the responses will appear here as key-value pairs.

    Example:

    ```json theme={null}

      "additionalDataToCollectOnCheckoutResponses": {
        "Field of Study": "Information Technology",
        "Counsellor ID": "2010MP4"
      }
    ```
</Accordion>

***

## 5. Payment Failed

**Event Trigger:** When a payment attempt fails.

This event is triggered anytime a student tries to pay for a course but the transaction fails due to various reasons.
You can gather information like **User Details**,  **Payment Gateway** information, **amount** in INR paise for the attempted transaction
and **Course details** for which the payment was being made.

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventPaymentFailedType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "payment-failed";
      } & {
          userId: string | null;
          userFullname: string;
          userEmail: string;
          userPhoneNumber: string | null;
          paymentGateway: "Paypal" | "PhonePe" | "Razorpay" | "Stripe" | "FermionUpi" | "SelfRazorpay";
          attempedChargeAmountInrPaise: number;
          courseSlug: string;
          courseName: string;
      };
  }
  ```

  **Payload Data:**

  * `userId`, `userFullname`, `userEmail`, `userPhoneNumber` – User details.
  * `paymentGateway` – Gateway used for the attempt.
  * `attempedChargeAmountInrPaise` – Amount attempted.
  * `courseSlug`, `courseName` – Course for which the payment failed.
</Accordion>

***

## 6. Payment Initiated But Never Completed

**Event Trigger:** When a payment is started but not completed within 60 minutes.

This event captures situations where a student begins the checkout process but abandons it before finishing it in under 60 minutes - commonly known as an “*abandoned cart*”

This could happen if the user gets distracted, changes their mind, or encounters a technical/payment issue.
This event webhook can be utilized for abandoned cart notifications or automated reminders.

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventPaymentInitiatedButNeverCompletedType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "payment-initiated-but-never-completed";
      } & {
          userId: string | null;
          userFullname: string;
          userEmail: string;
          userPhoneNumber: string | null;
          paymentGateway: ("Paypal" | "PhonePe" | "Razorpay" | "Stripe" | "FermionUpi") | null;
          attempedChargeAmountInrPaise: number | null;
          courseSlug: string;
          courseName: string;
      };
  }
  ```

  **Payload Description:**

  * `userId`, `userFullname`, `userEmail`, `userPhoneNumber` – User details.
  * `paymentGateway` – Gateway used (nullable if unknown).
  * `attempedChargeAmountInrPaise` – Amount attempted (nullable if unknown).
  * `courseSlug`, `courseName` – Course attempted.
</Accordion>

***

## 7. Recorded Video Ready for Playback

**Event Trigger:** When a video uploaded to Fermion is ready for playback.

Fermion automatically transcodes and optimizes every uploaded video to ensure smooth delivery across devices and bandwidths.
Once the processing is complete, this webhook is fired so you can trigger automated actions such as notifying students.

Learn more about Recorded Videos here: [Recorded Videos](/recorded-videos/introduction)

<Accordion title="Payload Description">
  ```tsx theme={null}
  type FermionWebhookEventRecodedVideoReadyForPlaybackType = {
      eventUniqueId: string;
      timestampIsoString: string;
      isTestEvent: boolean;
      payload: {
          eventType: "recoded-video-ready-for-playback";
      } & {
          videoId: string;
      };
  }
  ```

  **Payload Description:**

  * `videoId` – Unique ID of the video.
</Accordion>


# Quick Start
Source: https://docs.fermion.app/webhooks/getting-started

Learn how to set up and manage webhooks in Fermion.

Webhooks let Fermion send event notifications directly to your server.

<Info>
  If you have not enabled Webhooks, please go to **Manage features** > Scroll to **Development** > **Webhook** and enable that first from your instructor dashboard
</Info>

Follow these steps to set up your first webhook:

## Setting Up a Webhook

1. **Go to Webhooks Settings**\
   Open the **Webhooks** page in your Fermion dashboard.

2. **Create a Webhook**\
   Click **Add a new webhook** to create a new webhook template.

3. **Add Your Webhook URL**\
   Enter your server endpoint URL that will handle incoming webhook events and payload.

4. **Set a Webhook Secret**\
   Ensure the integrity of your webhook events by setting a secret. This secret will be sent in every webhook event in a header named `X-Fermion-Webhook-Secret`.
   Your server must validate all incoming requests and check if this header is present with the correct value.
   ![New Webhook](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/webhooknew.gxqjmv.png)

<Warning>
  Treat your webhook URL as a **secure endpoint**.  Only accept requests that contain the correct Fermion webhook secret.
</Warning>

5. **Subscribe to Events**\
   Choose the events you want this webhook to listen to. More information on events is provided in next sections.
   ![Subscribe Events](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/subscribedevents.cwdbmz.png)
6. **Save Configuration**\
   Click on Save Configuration to update your webhook settings.

***

## Multiple Webhooks & Event Subscriptions

You can create **multiple webhooks**, each subscribed to different events.\
This lets you send specific notifications to the right system.

**Examples:**

* Webhook 1 → Lab events → Sends data to an analytics system.
* Webhook 2 → Payment events → Sends data to accounting software.
* Webhook 3 → Captions → Sends caption data to your DB.

### Example Webhook Configuration

| Webhook   | Subscribed Events                 | Purpose                                         |
| --------- | --------------------------------- | ----------------------------------------------- |
| Webhook 1 | Lab Run Tests                     | Send lab results to an analytics system.        |
| Webhook 2 | Paid Product Sale, Payment Failed | Update accounting software with sales data.     |
| Webhook 3 | Live Event Session Caption Ready  | Automatically process captions for integration. |

<Tip>
  Using multiple webhooks keeps your integrations **organized, secure, and efficient**, since each system only receives the events it needs.
</Tip>


# Supported Events
Source: https://docs.fermion.app/webhooks/supported-events

Overview of all webhook events currently supported in Fermion.

Fermion currently supports a variety of webhook events that allow your external systems to stay in sync with activities on the platform.\
Each event represents a specific action or change in your courses, labs, live events, or digital products, and is delivered in real-time to your configured webhook endpoint.

By subscribing to the appropriate events, you can automate workflows, trigger notifications, and integrate seamlessly with third-party systems. For example, you could automatically update your CRM when a user enrolls, or trigger post-processing scripts when a live event video is ready.

| Event                                      | Description                                                                            | Feature                                              |
| ------------------------------------------ | -------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| **Lab Run Tests**                          | Triggered when a user presses the "Run Tests" button inside a lab.                     | [Labs](/creating-coding-labs/what-are-coding-labs)   |
| **Live Event Session Caption Ready**       | Triggered when captions are ready for a live event session.                            | [Captions](/live-classes/recording-and-captions)     |
| **Live Event Session Processed MP4 Ready** | Triggered when a processed MP4 is ready for a live event session.                      | [Live Classes](/live-classes/recording-and-captions) |
| **Paid Product Sale**                      | Triggered when a user purchases a paid product.                                        | [Payments](/setup-pricing/fixed-pricing-plan)        |
| **Payment Failed**                         | Triggered when a user's payment fails for any reason.                                  | [Payments](/setup-pricing/fixed-pricing-plan)        |
| **Payment Initiated But Never Completed**  | Triggered when a user initiates a purchase but does not complete it within 60 minutes. | [Payments](/setup-pricing/fixed-pricing-plan)        |
| **Recorded Video Ready for Playback**      | Triggered when a video uploaded to Fermion is ready for playback.                      | [Recorded Videos](/recorded-videos/introduction)     |

<Info>
  The details on how to subscribe to each event and use their payloads are explained in the following sections.

  It’s recommended to start with only the events you need, then expand as your integrations grow.
</Info>


# Utilizing Webhook Data
Source: https://docs.fermion.app/webhooks/using-data

How to process Fermion webhook data and access event logs.

When your server receives a webhook from Fermion, follow these practices to ensure reliable and secure processing:

1. **Verify the `X-Fermion-Webhook-Secret` header**\
   This ensures that the webhook request is authentic and actually sent by Fermion.

2. **Log `eventUniqueId`**\
   Each webhook event has a globally unique ID. Logging this helps prevent processing the same event multiple times.

3. **Use `timestampIsoString`**\
   This timestamp indicates when the event occurred. It is useful for ordering events chronologically or detecting delayed deliveries.

4. **Check `isTestEvent`**\
   Fermion allows you to send test events from the dashboard. Use this flag to distinguish between test and live events in your system.

5. **Process the `payload`**\
   The `payload` contains event-specific data. Handle it according to the event type for your workflow or automation.

<Tip>
  Always validate the webhook secret and log the `eventUniqueId`. This prevents duplicates and ensures your integrations remain secure and reliable.
</Tip>

***

# Accessing Webhook Event Logs

Fermion logs all webhook events, making it easy to monitor and troubleshoot your integrations:

* Navigate to the **Webhook** page in your dashboard and scroll further to view **Event Logs**.
* You can **view event details**, **copy data**, or **re-trigger the webhook** if your endpoint missed the original request.
* Each event shows the complete payload and metadata, so you can inspect exactly what was sent.

<Info>
  If an event fails to be processed, re-triggering it from the Event Logs is a quick way to recover without waiting for the next occurrence.
</Info>

![Event Logs](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/eventlogs.lgziou.png)

***

# Exporting Event Logs

For bulk analysis or backups, Fermion allows you to export event logs:

1. Click the **Export Data** button on the Event Logs page.
2. Select the **time range** and **specific events** you want to export.
3. The data will be exported as a **CSV file** and downloaded immediately to your device.

<Tip>
  Exporting event logs is useful for running scripts, audits, or keeping offline records of all webhook activity.
</Tip>

![Export Webhook Events](https://67d6ad5ef66ee0901532fd2f.storage.fermion.app/public-uncached/object-store-public-files/uploads/02-10-2025/exportevent.mcvgov.png)


# Introduction
Source: https://docs.fermion.app/webhooks/what-is-webhook

Understand how Fermion webhooks work and how you can integrate them in your system

Webhooks let you integrate Fermion with external systems by sending real-time notifications
when specific events occur in your courses or labs. You can now create multiple webhooks and subscribe each one to selected events,
ensuring notifications are sent only to the systems that need them.

# Understanding Webhooks

A **webhook** is a way for Fermion to send real-time notifications to an external system when something happens in your courses, labs, live events, or digital products.

Unlike APIs where your system must **poll** for updates, webhooks **push data automatically** to a URL you specify.

<Info>
  Think of it like Fermion “knocking on your server’s door” whenever an important event occurs.\
  This allows your system to respond immediately without constantly checking for changes.
</Info>

## Why use Webhooks?

Webhooks are useful for **automation** and keeping external systems in sync with your Fermion platform. Common use cases include:

* **CRM Notifications** – Notify a CRM when a student enrolls or interacts with a course.
* **Accounting Updates** – Update accounting software when a payment is completed.
* **Marketing Automation** – Trigger marketing workflows based on user activity.
* **Student Experience** – Provide third-party solutions to students automatically.