diff --git a/blazor-toc.html b/blazor-toc.html
index c2e88a806c..a57986d30a 100644
--- a/blazor-toc.html
+++ b/blazor-toc.html
@@ -4219,7 +4219,9 @@
 				<ul>
 					<li> <a href="/blazor/rich-text-editor/mention-integration">Mention Integration</a></li>
 					<li> <a href="/blazor/rich-text-editor/slash-commands">Slash Commands</a></li>
-					<li> <a href="/blazor/rich-text-editor/mail-merge">Mail Merge Integration</a></li>	
+					<li> <a href="/blazor/rich-text-editor/mail-merge">Mail Merge Integration</a></li>
+					<li> <a href="/blazor/rich-text-editor/image-editor-integration">Image Editor Integration</a></li>	
+					<li> <a href="/blazor/rich-text-editor/embedly">Embedly</a></li>	
 				</ul>
 			</li>
 			<li>Validation and Security
diff --git a/blazor/rich-text-editor/code-snippet/embedly-interop.js b/blazor/rich-text-editor/code-snippet/embedly-interop.js
new file mode 100644
index 0000000000..b4cd2e0a0f
--- /dev/null
+++ b/blazor/rich-text-editor/code-snippet/embedly-interop.js
@@ -0,0 +1,34 @@
+window.embedlyInterop = {
+    wrapLinkInEmbedlyCard: function() {
+        const rteContent = document.querySelector('.e-rte-content');
+        if (!rteContent) return;
+
+        const links = rteContent.querySelectorAll('a');
+        links.forEach(link => {
+            if (!link.closest('.embedly-card')) {
+                const blockquote = document.createElement('blockquote');
+                blockquote.className = 'embedly-card';
+
+                const a = document.createElement('a');
+                a.href = link.href;
+                a.textContent = link.textContent || link.href;
+
+                blockquote.appendChild(a);
+                blockquote.appendChild(document.createElement('p'));
+
+                link.parentNode.replaceChild(blockquote, link);
+            }
+        });
+
+        if (window.embedly && window.embedly.lib) {
+            window.embedly.lib.process(rteContent);
+        }
+    }
+};
+
+// Initialize Embedly processing on page load
+function initializeEmbedly() {
+    if (window.embedly && window.embedly.lib) {
+        window.embedly.lib.process(document.body);
+    }
+}
\ No newline at end of file
diff --git a/blazor/rich-text-editor/code-snippet/embedly.razor b/blazor/rich-text-editor/code-snippet/embedly.razor
new file mode 100644
index 0000000000..7600c84400
--- /dev/null
+++ b/blazor/rich-text-editor/code-snippet/embedly.razor
@@ -0,0 +1,46 @@
+@page "/embedly"
+
+@using Syncfusion.Blazor.RichTextEditor
+@using Syncfusion.Blazor
+
+@inject IJSRuntime JS
+
+<SfRichTextEditor @ref="Editor" Placeholder="Click link icon to add URLs">
+    <RichTextEditorToolbarSettings Items="@ToolbarItems"></RichTextEditorToolbarSettings>
+    <RichTextEditorEvents OnActionComplete="@OnActionComplete"></RichTextEditorEvents>
+    <RichTextEditorQuickToolbarSettings />
+    <RichTextEditorContent>
+        <p><strong>Embedly integration automatically transforms plain links into rich, interactive preview cards with titles, descriptions, and thumbnails.</strong></p>
+        <h4>How it works:</h4>
+        <ul>
+            <li><strong>Paste or create links</strong> - Use the CreateLink toolbar button to add URLs to the editor</li>
+            <li><strong>Automatic card rendering</strong> - Links are automatically converted to rich Embedly cards with preview, title, and description</li>
+            <li><strong>Supported content</strong> - Works with articles, videos, images, documents, and other embeddable web content</li>
+        </ul>
+    </RichTextEditorContent>
+</SfRichTextEditor>
+
+@code {
+    private SfRichTextEditor Editor;
+
+    private List<ToolbarItemModel> ToolbarItems = new()
+    {
+        new ToolbarItemModel { Command = ToolbarCommand.CreateLink }
+    };
+
+    private async Task OnActionComplete(ActionCompleteEventArgs args)
+    {
+        if (args.RequestType == "Links")
+        {
+            await JS.InvokeVoidAsync("embedlyInterop.wrapLinkInEmbedlyCard");
+        }
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await JS.InvokeVoidAsync("initializeEmbedly");
+        }
+    }
+}
\ No newline at end of file
diff --git a/blazor/rich-text-editor/code-snippet/image-editor-integration.razor b/blazor/rich-text-editor/code-snippet/image-editor-integration.razor
new file mode 100644
index 0000000000..bcfe636c7d
--- /dev/null
+++ b/blazor/rich-text-editor/code-snippet/image-editor-integration.razor
@@ -0,0 +1,231 @@
+@page "/imageeditorintegration"
+
+@using Syncfusion.Blazor.RichTextEditor
+@using Syncfusion.Blazor.ImageEditor
+@using Syncfusion.Blazor.Popups
+@inject IJSRuntime jsRuntime
+
+<SfRichTextEditor @ref="EditorRef" @bind-Value="RteValue">
+    <RichTextEditorToolbarSettings Items="@Items">
+        <RichTextEditorCustomToolbarItems>
+            <RichTextEditorCustomToolbarItem Name="ImageEditor">
+                <Template>
+                    <button class="e-tbar-btn e-btn e-icons edit" id="imageEditor" @onclick="OnImageEditorClick"><span class="e-btn-icon e-icons e-rte-image-editor"></span></button>
+                </Template>
+            </RichTextEditorCustomToolbarItem>
+        </RichTextEditorCustomToolbarItems>
+    </RichTextEditorToolbarSettings>
+    <RichTextEditorQuickToolbarSettings Image="@ImageQuickTools"></RichTextEditorQuickToolbarSettings>
+</SfRichTextEditor>
+
+<input type="file" id="rte-img-upload" style="display:none" accept="image/*" />
+
+<SfDialog @ref="DialogRef" @bind-Visible="@ShowDialog"
+          Header="Image Editor" Width="80%" Height="80vh" IsModal="true" ShowCloseIcon="true" ZIndex="10000">
+    <DialogEvents Opened="@OnDialogOpened" Closed="@OnDialogClosed" />
+    <DialogTemplates>
+        <Content>
+            @if (IsImageEditorOpen)
+            {
+                <SfImageEditor @ref="ImageEditorRef" Height="100%" Width="100%" Toolbar="@ImageEditorToolbar">
+                    <ImageEditorEvents Created="@OnEditorCreated" />
+                </SfImageEditor>
+            }
+        </Content>
+    </DialogTemplates>
+    <DialogButtons>
+        <DialogButton Content="Insert" IsPrimary="true" OnClick="@OnSaveReplace" />
+        <DialogButton Content="Cancel" OnClick="@OnCancel" />
+    </DialogButtons>
+    <DialogAnimationSettings Effect="DialogEffect.Zoom" />
+    <DialogPosition X="center" Y="center" />
+</SfDialog>
+
+@code {
+    private SfRichTextEditor EditorRef;
+    private SfDialog DialogRef;
+    private SfImageEditor ImageEditorRef;
+    private object DotNetRef;
+    private bool ShowDialog = false;
+    private bool IsImageEditorOpen = false;
+    private string CurrentImageSrc = string.Empty;
+    private string RteValue = @"<h2>Rich Text Editor with Image Editing</h2>
+    <p>This Rich Text Editor allows you to edit images directly within your content. Select any image and use the Edit Image button to access image editing tools.</p>
+    <h4>How to Use</h4>
+    <ol>
+    <li>Click on an image in the editor to select it</li>
+    <li>Click the <strong>Edit Image</strong> button in the main toolbar</li>
+    <li>Use the editing tools: crop, zoom, filter, annotate, and fine-tune</li>
+    <li>Click <strong>Insert</strong> to replace the original image with your edited version</li>
+    </ol>
+    <h4>Available Features</h4>
+    <ul>
+    <li>Crop and resize images</li>
+    <li>Apply filters and adjustments</li>
+    <li>Rotate and flip images</li>
+    <li>Add annotations and drawings</li>
+    <li>Support for JPG, PNG, GIF, and WebP formats</li>
+    </ul>
+    <h4>Sample Image</h4>
+    <p>Select the image below to start editing:</p>
+    <p><img id=""rteImageID"" style=""width: 300px; height: 200px; transform: rotate(0deg); border: 2px solid #ddd;"" alt=""Sample Image"" src=""https://cdn.syncfusion.com/ej2/richtexteditor-resources/RTE-Landscape.png"" class=""e-rte-image e-imginline""></p>";
+
+    private List<ImageEditorToolbarItemModel> ImageEditorToolbar = new List<ImageEditorToolbarItemModel>()
+    {
+        new ImageEditorToolbarItemModel() { Name = "Open" },
+        new ImageEditorToolbarItemModel() { Name = "Zoom" },
+        new ImageEditorToolbarItemModel() { Name = "Crop" },
+        new ImageEditorToolbarItemModel() { Name = "Annotation" },
+        new ImageEditorToolbarItemModel() { Name = "Finetune" },
+        new ImageEditorToolbarItemModel() { Name = "Filter" },
+        new ImageEditorToolbarItemModel() { Name = "Reset" }
+    };
+
+    private List<ToolbarItemModel> Items = new List<ToolbarItemModel>()
+    {
+        new ToolbarItemModel() { Command = ToolbarCommand.Undo },
+        new ToolbarItemModel() { Command = ToolbarCommand.Redo },
+        new ToolbarItemModel() { Command = ToolbarCommand.Separator },
+        new ToolbarItemModel() { Command = ToolbarCommand.Bold },
+        new ToolbarItemModel() { Command = ToolbarCommand.Italic },
+        new ToolbarItemModel() { Command = ToolbarCommand.Underline },
+        new ToolbarItemModel() { Command = ToolbarCommand.Separator },
+        new ToolbarItemModel() { Command = ToolbarCommand.CreateLink },
+        new ToolbarItemModel() { Command = ToolbarCommand.Image },
+        new ToolbarItemModel() { Command = ToolbarCommand.Separator },
+        new ToolbarItemModel() { Name = "ImageEditor", TooltipText = "Edit Image" },
+        new ToolbarItemModel() { Command = ToolbarCommand.SourceCode },
+        new ToolbarItemModel() { Command = ToolbarCommand.FullScreen }
+    };
+
+    private List<ImageToolbarItemModel> ImageQuickTools = new List<ImageToolbarItemModel>()
+    {
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Replace },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Align },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Caption },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Remove },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Separator },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.InsertLink },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Display },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.AltText },
+        new ImageToolbarItemModel() { Command = ImageToolbarCommand.Dimension }
+    };
+
+    protected override void OnInitialized()
+    {
+        DotNetRef = DotNetObjectReference.Create<object>(this as object);
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await jsRuntime.InvokeAsync<bool>("rteInterop.onInitialized", DotNetRef);
+        }
+    }
+
+    private async Task OnImageEditorClick()
+    {
+        if (EditorRef == null) {
+            return;
+        }
+        await EditorRef.SaveSelectionAsync();
+        var selectedHtml = await EditorRef.GetSelectedHtmlAsync();
+        if (string.IsNullOrWhiteSpace(selectedHtml) || !selectedHtml.Contains("<img", StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+        ExtractImageDetails(selectedHtml);
+        ShowDialog = true;
+        StateHasChanged();
+    }
+
+    private void ExtractImageDetails(string html)
+    {
+        try
+        {
+            var srcMatch = System.Text.RegularExpressions.Regex.Match(html, @"src=['\"]?([^'\"\s>]+)['\"]?", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
+            CurrentImageSrc = srcMatch.Success ? srcMatch.Groups[1].Value : string.Empty;
+        }
+        catch
+        {
+            CurrentImageSrc = string.Empty;
+        }
+    }
+
+    private void OnDialogOpened(Syncfusion.Blazor.Popups.OpenEventArgs args)
+    {
+        if (!IsImageEditorOpen)
+        {
+            IsImageEditorOpen = true;
+            StateHasChanged();
+        }
+    }
+
+    private void OnDialogClosed(Syncfusion.Blazor.Popups.CloseEventArgs args)
+    {
+        IsImageEditorOpen = false;
+    }
+
+    private async Task OnEditorCreated()
+    {
+        if (ImageEditorRef != null && !string.IsNullOrEmpty(CurrentImageSrc))
+        {
+            await Task.Delay(100);
+            await ImageEditorRef.OpenAsync(CurrentImageSrc);
+        }
+    }
+
+    [JSInvokable]
+    public async Task FileSelected(string imageUrl)
+    {
+        if (ImageEditorRef != null)
+        {
+            await ImageEditorRef.OpenAsync(imageUrl);
+        }
+    }
+
+    private async Task OnSaveReplace()
+    {
+        if (ImageEditorRef == null || EditorRef == null) {
+            return;
+        }
+        
+        var imageDataUrl = await ImageEditorRef.GetImageDataUrlAsync();
+        if (string.IsNullOrEmpty(imageDataUrl)) {
+            return;
+        }
+        
+        string newImageHtml = $@"<img id=\"rteImageID\" style=\"width: 300px; height: 200px; transform: rotate(0deg); border: 2px solid #ddd;\" alt=\"Edited Image\" src=\"{imageDataUrl}\" class=\"e-rte-image e-imginline\">";
+        
+        if (!string.IsNullOrEmpty(CurrentImageSrc))
+        {
+            string escapedOldSrc = System.Text.RegularExpressions.Regex.Escape(CurrentImageSrc);
+            RteValue = System.Text.RegularExpressions.Regex.Replace(
+                RteValue, 
+                @"<img[^>]*src=\"?" + escapedOldSrc + @"\"?[^>]*>", 
+                newImageHtml,
+                System.Text.RegularExpressions.RegexOptions.IgnoreCase
+            );
+        }
+        else
+        {
+            RteValue += newImageHtml;
+        }
+        
+        ShowDialog = false;
+        CurrentImageSrc = string.Empty;
+        StateHasChanged();
+    }
+
+    private Task OnCancel()
+    {
+        ShowDialog = false;
+        return Task.CompletedTask;
+    }
+}
+<style>
+    .e-icons.edit::before {
+        content: '\e730';
+    }
+</style>
\ No newline at end of file
diff --git a/blazor/rich-text-editor/code-snippet/image-editor-interop.js b/blazor/rich-text-editor/code-snippet/image-editor-interop.js
new file mode 100644
index 0000000000..405bf14e88
--- /dev/null
+++ b/blazor/rich-text-editor/code-snippet/image-editor-interop.js
@@ -0,0 +1,64 @@
+window.canvasInterop = {
+    detectedFormat: null
+};
+
+window.rteInterop = {
+    objRef: null,
+    onInitialized: function (objRef) {
+        window.rteInterop.objRef = objRef;
+        var fileInput = document.getElementById('rte-img-upload');
+        if (fileInput) {
+            fileInput.onchange = function (e) {
+                if (e.target.files && e.target.files.length > 0) {
+                    var file = e.target.files[0];  
+                    window.canvasInterop.detectedFormat = file.type;
+                    var reader = new FileReader();
+                    reader.onload = function (event) {
+                        window.rteInterop.objRef.invokeMethodAsync('FileSelected', event.target.result);
+                    };
+                    reader.readAsDataURL(file);
+                    e.target.value = '';
+                }
+            };
+        }
+        return true;
+    },
+    fileSelect: function () {
+        var inputFile = document.getElementById('rte-img-upload');
+        if (inputFile) {
+            inputFile.click();
+        }
+        return true;
+    },
+    getEditedImageData: function () {
+        var imageEditor = document.querySelector('.e-image-editor');
+        if (!imageEditor) {
+            return '';
+        }
+        var dataId = imageEditor.getAttribute('data-control-id');
+        var instance = null;
+        
+        if (!dataId && window.sfBlazor) {
+            instance = window.sfBlazor.getCompInstance(imageEditor);
+        } else if (dataId && window.sfBlazor) {
+            instance = window.sfBlazor.getCompInstance(dataId);
+        }
+        
+        if (instance && instance.getImageData) {
+            var imageData = instance.getImageData();
+            if (imageData) {
+                var tempCanvas = document.createElement('canvas');
+                tempCanvas.width = imageData.width;
+                tempCanvas.height = imageData.height;
+                var ctx = tempCanvas.getContext('2d');
+                ctx.putImageData(imageData, 0, 0); 
+                if (window.canvasInterop.detectedFormat) {
+                    return tempCanvas.toDataURL(window.canvasInterop.detectedFormat);
+                } else {
+                    return tempCanvas.toDataURL();
+                }
+            }
+        }
+        return '';
+    }
+};
\ No newline at end of file
diff --git a/blazor/rich-text-editor/embedly.md b/blazor/rich-text-editor/embedly.md
new file mode 100644
index 0000000000..e77185a9f8
--- /dev/null
+++ b/blazor/rich-text-editor/embedly.md
@@ -0,0 +1,158 @@
+---
+layout: post
+title: Embedly Integration with RichTextEditor Component | Syncfusion
+description: Checkout and learn how to integrate Embedly with Blazor RichTextEditor to convert URLs into rich preview cards for enhanced content presentation.
+platform: Blazor
+control: RichTextEditor
+documentation: ug
+---
+
+# Embedly Integration with RichTextEditor
+
+By integrating [Embedly](https://www.embedly.com) with the Blazor RichTextEditor, you can automatically convert URLs into rich preview cards. This integration allows users to insert links that render as interactive embed cards, enhancing the visual presentation and user experience when sharing web content.
+
+## Overview
+
+This documentation provides a complete integration of Embedly with the RichTextEditor component. Users can:
+
+- Insert links in the editor content
+- Links automatically render as interactive Embedly embed cards
+- Support for various content types (videos, articles, social media, etc.)
+- Interactive embed cards enhance content visibility and engagement
+
+## Prerequisites
+
+- **Syncfusion.Blazor NuGet package** installed and configured
+- **Required namespaces:**
+  - `Syncfusion.Blazor.RichTextEditor`
+- **JavaScript interop enabled** — `IJSRuntime` support
+- **Embedly CDN access** — https://cdn.embedly.com/widgets/platform.js
+
+> Before integrating Embedly with RichTextEditor, refer to the [RichTextEditor Getting Started](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started) documentation for initial setup.
+
+## Step 1: Add the JavaScript Interop File
+
+Create the JavaScript interop module to handle link processing and communication between Blazor and Embedly.
+
+### 1.1 Create the interop file
+
+In your Blazor project, create a new folder `wwwroot/scripts/` and add a file named `embedly-interop.js`.
+
+Copy the complete interop implementation from:
+
+{% highlight javascript %}
+{% include_relative code-snippet/embedly-interop.js %}
+{% endhighlight %}
+
+### 1.2 Verify file placement
+
+Ensure the file is located at:
+
+```
+YourProject/
+└── wwwroot/
+    └── scripts/
+        └── embedly-interop.js
+```
+
+## Step 2: Add Script Reference in Host Page
+
+Add the script references in your host page before the closing `</body>` tag:
+
+```html
+<script src="https://cdn.embedly.com/widgets/platform.js" charset="UTF-8"></script>
+<script src="/scripts/embedly-interop.js"></script>
+</body>
+```
+
+> The host page location varies by project type. Refer to the [RichTextEditor Getting Started](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started) guide for the correct host page file path.
+>
+> **Note:** The Embedly CDN script (`https://cdn.embedly.com/widgets/platform.js`) must be loaded before the custom interop file to ensure proper functionality.
+
+## Step 3: Create the Razor Component
+
+In your Blazor project's `Pages` folder, create a new file: `EmbedlyIntegration.razor`
+
+Copy the complete component implementation from:
+
+{% highlight cshtml %}
+{% include_relative code-snippet/embedly.razor %}
+{% endhighlight %}
+
+## How to Use the Integration
+
+1. **Navigate to the component** — Open the page where you created the component (e.g., `/embedlyintegration`)
+2. **Insert a link** — Use the RichTextEditor's link tool to insert a URL
+3. **View embed card** — The link automatically renders as an Embedly embed card
+4. **Interact with content** — Click on the embed card to interact with the content (watch videos, view articles, etc.)
+
+![Blazor RichTextEditor with Embedly Integration](./images/blazor-richtexteditor-embedly.png)
+
+## How It Works
+
+When a user inserts or updates a link in the RichTextEditor:
+
+1. The `OnActionComplete` event is triggered with `RequestType` set to "Links"
+2. The JavaScript interop method `embedlyInterop.wrapLinkInEmbedlyCard()` is invoked via `JS.InvokeVoidAsync`
+3. The method queries the RichTextEditor content area using the `.e-rte-content` selector
+4. Each link is wrapped in a `blockquote` element with the `.embedly-card` class
+5. The Embedly library processes the container to render the interactive embed card preview
+
+## Supported content
+
+Embedly supports embedding from a wide range of sources including:
+
+- Video platforms (YouTube, Vimeo, etc.)
+- Social media (Twitter, Instagram, Facebook, etc.)
+- Articles and blog posts
+- Music services
+- Image galleries
+- And many more content types
+
+For a complete list of supported services, refer to the [Embedly documentation](https://www.embedly.com/).
+
+## Preventing duplicate processing
+
+The JavaScript interop includes a check to prevent duplicate embed card wrapping:
+
+```javascript
+if (!link.closest('.embedly-card')) {
+    // Process the link only if it's not already wrapped
+}
+```
+
+This ensures that links are only wrapped once, preventing duplicate Embedly card structures when the same link is processed multiple times.
+
+## Integration points
+
+### Toolbar configuration
+
+The `ToolbarItems` list includes only the `CreateLink` command to allow users to insert links:
+
+```csharp
+private List<ToolbarItemModel> ToolbarItems = new()
+{
+    new ToolbarItemModel { Command = ToolbarCommand.CreateLink }
+};
+```
+
+### Event handling
+
+The `OnActionComplete` event checks if the action is a link insertion and triggers the Embedly processing:
+
+```csharp
+private async Task OnActionComplete(ActionCompleteEventArgs args)
+{
+    if (args.RequestType == "Links")
+    {
+        await JS.InvokeVoidAsync("embedlyInterop.wrapLinkInEmbedlyCard");
+    }
+}
+```
+
+## See also
+
+* [Link support in RichTextEditor](https://blazor.syncfusion.com/documentation/rich-text-editor/link)
+* [Rich Text Editor documentation](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started)
+* [Rich Text Editor events](https://blazor.syncfusion.com/documentation/rich-text-editor/events)
+* [Embedly Developer Documentation](https://www.embedly.com)
\ No newline at end of file
diff --git a/blazor/rich-text-editor/image-editor-integration.md b/blazor/rich-text-editor/image-editor-integration.md
new file mode 100644
index 0000000000..03c41d21e2
--- /dev/null
+++ b/blazor/rich-text-editor/image-editor-integration.md
@@ -0,0 +1,115 @@
+---
+layout: post
+title: Image Editor Integration with RichTextEditor Component | Syncfusion
+description: Checkout and learn how to integrate the Syncfusion Image Editor with Blazor RichTextEditor to edit images directly within the content.
+platform: Blazor
+control: RichTextEditor
+documentation: ug
+---
+
+# Image Editor Integration with RichTextEditor
+
+The Blazor [RichTextEditor](https://www.syncfusion.com/blazor-components/blazor-wysiwyg-rich-text-editor) component can be enhanced with [ImageEditor](https://www.syncfusion.com/blazor-components/blazor-image-editor) capabilities to allow users to edit images directly within the editor content. This integration enables inline image editing, such as cropping, applying filters, rotating, and adding annotations without leaving the editor interface.
+
+## Overview
+
+This documentation provides a complete integration of the Syncfusion ImageEditor with the RichTextEditor component. Users can:
+
+- Select an image in the editor content
+- Click the "Edit Image" toolbar button to open an image editing dialog
+- Edit the image using various tools (crop, zoom, filter, annotate, fine-tune)
+- Replace the original image with the edited version
+
+## Prerequisites
+
+- **Syncfusion.Blazor NuGet package** installed and configured
+- **Required namespaces:**
+  - `Syncfusion.Blazor.RichTextEditor`
+  - `Syncfusion.Blazor.ImageEditor`
+  - `Syncfusion.Blazor.Popups`
+- **JavaScript interop enabled** — `IJSRuntime` support
+- **Host page access** for script references
+
+> Before integrating Image Editor with RichTextEditor, refer to the [RichTextEditor Getting Started](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started) documentation for initial setup.
+
+## Step 1: Add SignalR Configuration to Program.cs
+
+After following the RichTextEditor Getting Started guide, add the SignalR configuration to your `Program.cs` file to handle large image data transmission during image editing:
+
+**Add this line to your Program.cs:**
+
+```csharp
+using Microsoft.AspNetCore.SignalR;
+
+builder.Services.Configure<HubOptions>(o => o.MaximumReceiveMessageSize = 1024 * 1024);
+```
+
+This line should be added after your existing Syncfusion service registration:
+
+```csharp
+builder.Services.AddSyncfusionBlazor();
+builder.Services.Configure<HubOptions>(o => o.MaximumReceiveMessageSize = 1024 * 1024);
+```
+
+> The `MaximumReceiveMessageSize` configuration allows large image data to be transmitted through SignalR when editing and saving large images. The default value is 32 KB, which may be insufficient for large images.
+
+## Step 2: Add the JavaScript Interop File
+
+Create the JavaScript interop module to handle file selection and communication between Blazor and the Image Editor.
+
+### 2.1 Create the interop file
+
+In your Blazor project, create a new folder `wwwroot/scripts/` and add a file named `rte-imageeditor-interop.js`.
+
+Copy the complete interop implementation from:
+
+{% highlight javascript %}
+{% include_relative code-snippet/image-editor-interop.js %}
+{% endhighlight %}
+
+### 2.2 Verify file placement
+
+Ensure the file is located at:
+
+```
+YourProject/
+└── wwwroot/
+    └── scripts/
+        └── rte-imageeditor-interop.js
+```
+
+## Step 3: Add Script Reference in Host Page
+
+Add the script reference in your host page before the closing `</body>` tag:
+
+```html
+<script src="/scripts/rte-imageeditor-interop.js"></script>
+</body>
+```
+
+> The host page location varies by project type. Refer to the [RichTextEditor Getting Started](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started) guide for the correct host page file path.
+
+## Step 4: Create the Razor Component
+
+In your Blazor project's `Pages` folder, create a new file: `ImageEditorIntegration.razor`
+
+Copy the complete component implementation from:
+
+{% highlight cshtml %}
+{% include_relative code-snippet/image-editor-integration.razor %}
+{% endhighlight %}
+
+## How to Use the Integration
+
+1. **Navigate to the component** — Open the page where you created the component (e.g., `/imageeditorintegration`)
+2. **Insert an image** — Use the RichTextEditor's image tool to insert an image
+3. **Select and edit** — Click on the image to select it, then click the "Edit Image" button
+4. **Use image tools** — Crop, rotate, filter, annotate, or fine-tune the image as needed
+5. **Save changes** — Click "Insert" to replace the original image with the edited version
+
+## See also
+
+* [Image support in RichTextEditor](https://blazor.syncfusion.com/documentation/rich-text-editor/image)
+* [Rich Text Editor documentation](https://blazor.syncfusion.com/documentation/rich-text-editor/getting-started)
+* [Image Editor documentation](https://blazor.syncfusion.com/documentation/image-editor/getting-started)
+* [Dialog documentation](https://blazor.syncfusion.com/documentation/dialog/getting-started)
\ No newline at end of file
diff --git a/blazor/rich-text-editor/images/blazor-richtexteditor-embedly.png b/blazor/rich-text-editor/images/blazor-richtexteditor-embedly.png
new file mode 100644
index 0000000000..15cc8ca00d
Binary files /dev/null and b/blazor/rich-text-editor/images/blazor-richtexteditor-embedly.png differ