- Primary Toolbar
diff --git a/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-large-pdf.md b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-large-pdf.md
new file mode 100644
index 000000000..8b1df083f
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-large-pdf.md
@@ -0,0 +1,105 @@
+---
+layout: post
+title: Document Handling in Blazor PDF Viewer Component | Syncfusion
+description: Learn how to load and render large PDF files in the Syncfusion Blazor PDF Viewer using chunk-based processing
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Load Large PDF Files in Blazor PDF Viewer
+
+This section explains how to load and render **large PDF files (up to approximately 1 GB)** efficiently using the Syncfusion Blazor PDF Viewer. It also covers the recommended configurations required to achieve stable and responsive performance while working with large documents.
+
+Large PDF rendering in the Blazor PDF Viewer is supported through **chunk-based processing**, which allows the document to be processed incrementally instead of downloading and rendering the entire file in a single request.
+
+## Why Large PDFs Require Special Handling
+
+Large PDF files may contain:
+
+- High‑resolution images
+- Compressed streams
+- Digital signatures
+- Form fields and annotations
+- Vector graphics and complex page layouts
+
+Loading and processing such files in a single request can cause high memory usage and browser limitations. Chunk-based processing ensures the document is streamed and rendered progressively, improving reliability and performance.
+
+## Viewer Capability Overview
+
+With proper configuration, the Blazor PDF Viewer can:
+
+- Render large PDF files up to **~1 GB**
+- Load and process documents incrementally using chunks
+- Improve page navigation and scrolling responsiveness
+- Reduce memory pressure on the browser
+
+N> Large PDF support depends on enabling chunk-based processing and proper server configuration. The actual supported size may vary based on browser memory limits, server settings, and system resources.
+
+---
+
+## Best Practices for Loading Large PDFs
+
+### 1. Enable Chunk‑Based Processing
+
+Chunk-based processing is **mandatory** for loading large PDF files in the Blazor PDF Viewer. It allows the document to be processed in smaller byte ranges instead of transferring the entire file at once.
+
+Refer to the following FAQ to configure chunk-based processing:
+
+- [How to process Larges files using EnableChunkMessages](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faqs/how-to-processing-large-files-without-increasing-maximum-message-size)
+
+Ensure that:
+
+- The server supports **HTTP range requests**
+- Chunk processing is enabled as documented
+- Connection buffer limits are configured correctly
+
+### 2. Load Large PDFs Using `DocumentPath`
+
+For large documents, it is recommended to load the PDF using the [DocumentPath](https://help.syncfusion.com/cr/blazor/Syncfusion.Blazor.SfPdfViewer.PdfViewerBase.html#Syncfusion_Blazor_SfPdfViewer_PdfViewerBase_DocumentPath) property.
+
+Using `DocumentPath` helps:
+
+- Initiate chunk-based requests immediately
+- Avoid loading the entire document into memory
+- Improve stability and loading behavior for large files
+
+This approach is suitable for PDFs hosted on servers, secured APIs, or cloud storage endpoints.
+
+---
+
+### 3. Optimize Network and Performance Configuration
+
+Proper network configuration plays a critical role in rendering large PDFs.
+
+#### Increase Connection Buffer Size
+
+Configuring a sufficient connection buffer size helps prevent interruptions while loading large documents:
+
+- [How to increase connection Buffer size](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faqs/how-to-increase-connection-buffer-size)
+
+#### Use CDN for Improved Performance
+
+Using CDN resources reduces script download time and improves viewer initialization performance:
+
+- [How to improve performance using CDN](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faqs/how-to-improve-performance-using-cdn)
+
+---
+
+### 4. Reduce System Resource Load
+
+Rendering large PDF files also depends on available system resources.
+
+For the best experience:
+
+- Close unused applications
+- Minimize open browser tabs
+- Avoid running multiple heavy tasks in parallel
+- Do not open multiple large PDFs at the same time
+
+Ensuring adequate system memory and CPU availability helps maintain smooth rendering and interaction.
+
+## See Also
+
+- [Load and Save Sample](https://github.com/SyncfusionExamples/blazor-pdf-viewer-examples/tree/master/Load%20and%20Save)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-password-pdf.md b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-password-pdf.md
new file mode 100644
index 000000000..e3eb1ac5e
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/load-password-pdf.md
@@ -0,0 +1,95 @@
+---
+layout: post
+title: Load Password Protected PDFs in Blazor PDF Viewer | Syncfusion
+description: Learn how to open password-protected PDF files in the Syncfusion Blazor PDF Viewer by providing the password in the documentPath object.
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Load a Password-Protected PDF in Blazor
+
+This article explains how to open password-protected PDF files in the Syncfusion Blazor PDF Viewer. The viewer supports both user‑interactive loading (Open File dialog) and programmatic loading using APIs.
+
+## 1. Opening a Password-Protected PDF Using the **Open File** Dialog
+
+When the user selects a password-protected PDF using the built‑in **Open File** option:
+
+- The viewer detects that the document is encrypted
+
+
+
+- A **password input popup** is automatically displayed
+
+
+
+- The user enters the password
+
+- The document is decrypted and loaded
+
+No additional configuration or code is required.
+
+This approach works for all password-protected PDFs opened locally by the user.
+
+## 2. Opening a Password-Protected PDF Programmatically
+
+If you load a password-protected PDF from a URL or through custom logic, the viewer provides two behaviors depending on how the file is loaded.
+
+### 2.1 Load the Document Using `LoadAsync(byte[] bytes, string password = null)`
+
+You can directly pass the password in the [`load`](https://help.syncfusion.com/cr/blazor/Syncfusion.Blazor.SfPdfViewer.PdfViewerBase.html#Syncfusion_Blazor_SfPdfViewer_PdfViewerBase_LoadAsync_System_Byte___System_String_) method:
+
+```cs
+@using Syncfusion.Blazor.SfPdfViewer
+@using Syncfusion.Blazor.Buttons
+
+Load Document
+
+
+
+@code{
+ SfPdfViewer2 Viewer;
+
+ public async void clicked()
+ {
+ await Viewer.LoadAsync("wwwroot/pdf-succinctly-password-protected.pdf", "password");
+ }
+}
+```
+
+- If the password is correct → the PDF loads immediately
+- If the password is incorrect → the viewer displays the incorrect password popup
+- If no password is provided → the password popup is shown automatically
+
+This is useful when the password is known beforehand.
+
+### 2.2 Loading a Password-Protected Document's URL Using `documentPath`
+
+If the [`documentPath`](https://help.syncfusion.com/cr/blazor/Syncfusion.Blazor.SfPdfViewer.PdfViewerBase.html#Syncfusion_Blazor_SfPdfViewer_PdfViewerBase_DocumentPath) points to a password-protected PDF:
+
+```cs
+@using Syncfusion.Blazor
+@using Syncfusion.Blazor.SfPdfViewer
+
+
+
+
+@code {
+ //Load URL for Passwrod-Protected Document in DocumentPath
+ public string DocumentPath { get; set; } = "https://cdn.syncfusion.com/content/pdf/pdf-succinctly.pdf";
+}
+```
+
+The viewer will:
+
+- Detect encryption
+- Show the **password popup automatically**
+- Allow the user to enter the correct password
+- Then load the PDF
+
+
+
+N> No password should be passed inside `documentPath`.
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/preprocess-pdf.md b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/preprocess-pdf.md
new file mode 100644
index 000000000..bdf5f7778
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/preprocess-pdf.md
@@ -0,0 +1,199 @@
+---
+layout: post
+title: Preprocess PDF Document in Blazor PDF Viewer | Syncfusion
+description: Learn how to preprocess PDF documents using Syncfusion PDF Library before displaying them in the Blazor PDF Viewer.
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Pre-process PDF Document Before Displaying in Blazor PDF Viewer
+
+This section explains why preprocessing is useful, what operations you can perform using the Syncfusion PDF Library and Blazor PDF Viewer, and how to load the processed document in the Blazor PDF Viewer.
+
+## Why Preprocessing Is Needed
+Preprocessing a PDF before sending it to the viewer helps you:
+- Reduce file size and improve load time
+- Merge multiple documents into one
+- Extract only required pages for faster loading
+- Flatten form fields and annotations for performance & security
+- Apply branding elements such as watermarks or stamps
+
+These enhancements ensure a better, faster, and more controlled viewing experience.
+
+## Merge PDF Documents
+### UI-Level Merging
+You can visually merge pages in the **Organize Pages** UI inside the Blazor PDF Viewer. Users can import another PDF, insert its pages into the current file, reorder pages, or delete unwanted pages.
+
+
+
+For more details, refer to [UI Interactions - Import Pages](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/organize-pages/ui-interactions#import-pages).
+
+### Programmatically Merge PDFs
+Using the Syncfusion PDF Viewer, you can merge documents before loading them into the viewer.
+
+For more details, refer to [Programmatic Support - Import Pages](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/organize-pages/programmatic-support#import-pages).
+
+N> You can then load the merged PDF into the viewer using a file path or stream.
+
+## Extract Pages
+### UI-Level Extraction
+Using the Viewer's **Organize Pages** window, users can select and extract required pages and download them separately.
+
+
+
+For more details, refer to [UI Interactions - Extract Pages](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/organize-pages/ui-interactions#extract-pages).
+
+### Programmatically Extract Pages
+Using the Viewer's **Organize Pages** window, users can select and extract required pages and download them separately programmatically.
+
+For more details, refer to [Programmatic Support - Export Pages](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/organize-pages/programmatic-support#export-pages).
+
+## Flatten Form Fields & Annotations
+### Why Flattening Helps
+- Prevents users from editing form fields
+- Improves rendering speed
+- Ensures consistent appearance across all devices
+
+### Flatten on Load
+
+Use the following code-snippet when you want uploaded PDFs to be flattened before they are loaded into the viewer.
+
+```cs
+@page "/"
+@using Syncfusion.Blazor
+@using Syncfusion.Blazor.SfPdfViewer
+@using Syncfusion.Pdf
+@using Syncfusion.Pdf.Parsing
+
+
+
+
+@code{
+
+ private SfPdfViewer2? Viewer;
+
+ async Task OnCreated()
+
+ {
+
+ if (Viewer is null) return;
+ PdfLoadedDocument loadedDocument = new PdfLoadedDocument("wwwroot/Annotations.pdf");
+
+ if (loadedDocument.Form !=null)
+ {
+ // Flatten form fields
+ loadedDocument.Form.Flatten = true;
+ }
+
+ // Flatten annotations
+ foreach (PdfLoadedPage page in loadedDocument.Pages)
+ {
+ page.Annotations.Flatten = true;
+ }
+
+ // Save flattened PDF to byte[]
+ byte[] flattenedBytes;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ loadedDocument.Save(stream);
+ flattenedBytes = stream.ToArray();
+ }
+ loadedDocument.Close(true);
+ // Reload flattened document into viewer
+ await Viewer.LoadAsync(flattenedBytes);
+
+ }
+
+}
+```
+
+## Add Watermark or Stamp
+### UI-Level Stamps
+The Blazor PDF Viewer toolbar allows users to:
+- Add [standard stamps](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/annotation/stamp-annotation#add-stamp-annotations-to-the-pdf-document)
+- Insert [custom image stamps](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/annotation/stamp-annotation#add-a-custom-stamp)
+
+
+
+### Programmatically Add a Watermark
+
+```csharp
+@page "/"
+@using Syncfusion.Blazor
+@using Syncfusion.Blazor.SfPdfViewer
+@using Syncfusion.Pdf
+@using Syncfusion.Pdf.Graphics
+@using Syncfusion.Pdf.Parsing
+@inject IWebHostEnvironment Env
+
+
+
+
+
+@code {
+ private SfPdfViewer2 Viewer;
+
+ // Dummy watermark image base64 (replace with actual value)
+ private string WatermarkImageBase64 = "/9j/4AAQSkZJRgABAQAAAQA..";
+
+ private async Task LoadPdf()
+ {
+ string pdfPath = Path.Combine(Env.WebRootPath, "pdf-succinctly.pdf");
+
+ using FileStream inputStream = new FileStream(pdfPath, FileMode.Open, FileAccess.Read);
+ PdfLoadedDocument loadedDocument = new PdfLoadedDocument(inputStream);
+
+ byte[] imageBytes = Convert.FromBase64String(WatermarkImageBase64);
+ using MemoryStream imageStream = new MemoryStream(imageBytes);
+ PdfImage image = PdfImage.FromStream(imageStream);
+
+ foreach (PdfPageBase page in loadedDocument.Pages)
+ {
+ PdfGraphics graphics = page.Graphics;
+ float pageWidth = page.Size.Width;
+ float pageHeight = page.Size.Height;
+
+ float desiredWidth = pageWidth / 2;
+ float desiredHeight = image.Height * (desiredWidth / image.Width);
+ float x = (pageWidth - desiredWidth) / 2;
+ float y = (pageHeight - desiredHeight) / 2;
+
+ graphics.SetTransparency(0.25f);
+ graphics.DrawImage(image, x, y, desiredWidth, desiredHeight);
+ }
+
+ using MemoryStream outputStream = new MemoryStream();
+ loadedDocument.Save(outputStream);
+ loadedDocument.Close(true);
+
+ await Viewer.LoadAsync(outputStream.ToArray());
+ }
+}
+```
+
+## How-To Guide: Load the Preprocessed PDF in the Viewer
+
+You can load the processed PDF using a remote URL, stream, or byte array and base64 Data.
+
+### Load From Remote URL
+
+Refer to the Syncfusion Blazor PDF Viewer documentation for loading PDF from Remote URL. For more details, visit [Load PDF Document from Remote URL](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/opening-pdf-file#opening-a-pdf-from-remote-url).
+
+https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/opening-pdf-file#opening-a-pdf-from-remote-url
+
+### Load Using Stream or Byte Array
+
+Refer to the Syncfusion Blazor PDF Viewer documentation for loading PDF from stream or byte array. For more details, visit [Load PDF Document from Stream](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/opening-pdf-file#opening-a-pdf-from-stream).
+
+### Load Using base64 Data
+
+Refer to the Syncfusion Blazor PDF Viewer documentation for loading PDF from base64 data. For more details, visit [Load PDF Document from base64 Data](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/opening-pdf-file#opening-a-pdf-from-base64-data).
+
+## Additional Performance Tips
+
+- **Render Multiple Pages While Scrolling:** Improve performance by rendering multiple pages during scrolling. For more details, refer to [How to render N pages while scrolling](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faqs/how-to-render-n-pages-scrolling).
+- **Improve Performance Using CDN:** Enhance viewer performance using a Content Delivery Network. For more details, refer to [How to improve performance using CDN](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faqs/how-to-improve-performance-using-cdn).
+
+
diff --git a/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/retrieve-loaded-document.md b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/retrieve-loaded-document.md
new file mode 100644
index 000000000..b2db990b9
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/blazor/document-handling/retrieve-loaded-document.md
@@ -0,0 +1,171 @@
+---
+layout: post
+title: Retrieve the Loaded Document in Blazor PDF Viewer | syncfusion
+description: Learn how to access the loaded PDF document instance in the Blazor PDF Viewer using component references and the DocumentLoad event.
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Retrieve the Loaded Document Instance in Blazor PDF Viewer
+
+This page explains how to access the Blazor PDF Viewer instance using Blazor component references, listen for the `OnCreated` event, and retrieve document information, page details, and metadata—so you can safely invoke viewer APIs after the PDF is loaded.
+
+## Explanation: Why access the loaded document instance?
+
+- The viewer instance (via **Blazor component reference**) gives you a stable handle to call APIs such as [`Zoom`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/magnification), [`Print`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/print), [`Download`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/saving-pdf-file#download), and [`Navigation`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/navigation).
+- The **OnCreated event** (fires after the PDF is parsed and pages are ready) is the correct moment to read **document information** (title, author, page count, etc.) and **page metrics**, and to trigger post‑load UI logic.
+- Accessing the instance too early (before load completes) may cause null/undefined errors or incomplete information.
+
+## Reference: What you can access/call after load
+
+After the PDF is loaded you can:
+
+- **Read document information**: title, author, subject, keywords (metadata), page count.
+- **Read page details**: total pages, current page, page size(s).
+- **Call Viewer APIs** (typical examples):
+ - **Zoom / Fit**: `ZoomTo(125)`; fit to page/width
+ - **Navigation**: go to a specific page
+ - **Interactions**: enable/disable features
+ - **Export**: `Download()`, `Print()`
+
+> Always invoke these after the `OnCreated` event fires, or from user actions that occur after load. Guard calls with null checks or readiness flags.
+
+## How‑to: Get the instance with a ref and read details on load
+
+Below is a focused snippet showing:
+1) Creating a **component reference** for the viewer,
+2) Wiring the **`OnCreated`** event, and
+3) Reading basic **document info** and **page count**, then calling **viewer APIs** safely.
+
+```cs
+@page "/"
+
+@using Syncfusion.Blazor
+@using Syncfusion.Blazor.SfPdfViewer
+@using Syncfusion.Pdf
+@using Syncfusion.Pdf.Parsing
+
+
+ Document Info
+ Name: @Info.Name
+ Pages: @Info.PageCount
+ Title: @Info.Title
+ Author: @Info.Author
+
+
+
+
+@code {
+
+ private SfPdfViewer2? Viewer;
+
+ private DocumentInfo Info = new();
+
+ private async Task OnCreated()
+ {
+ string filePath = "wwwroot/pdf-succinctly.pdf";
+
+ //Load using Syncfusion.Pdf
+ PdfLoadedDocument doc = new PdfLoadedDocument(filePath);
+
+ //Read document info
+ Info = new DocumentInfo
+ {
+ Name = Path.GetFileName(filePath),
+ PageCount = doc.Pages.Count,
+ Title = doc.DocumentInformation.Title,
+ Author = doc.DocumentInformation.Author
+ };
+
+ //Load into the viewer
+ using MemoryStream ms = new();
+ doc.Save(ms);
+ byte[] bytes = ms.ToArray();
+
+ doc.Close(true);
+
+ await Viewer!.LoadAsync(bytes);
+ }
+
+ class DocumentInfo
+ {
+ public string Name { get; set; } = "";
+ public int PageCount { get; set; }
+ public string Title { get; set; } = "";
+ public string Author { get; set; } = "";
+ }
+}
+```
+
+**Notes**
+- Use `SfPdfViewer2` component with `@ref` to get direct access to the viewer instance.
+- Call methods directly on the viewer reference like `Viewer.ZoomAsync()`, `Viewer.GoToPageAsync()`, etc.
+
+## Tutorial: End‑to‑End — Call Viewer APIs with TextBox Input
+
+This example demonstrates how to use text input with buttons to interact with the loaded PDF viewer:
+
+```cs
+@page "/"
+@using Syncfusion.Blazor.Buttons
+@using Syncfusion.Blazor.Inputs
+@using Syncfusion.Blazor.SfPdfViewer
+
+
+
+
+Zoom
+
+
+
+
+Go To Page
+Download
+Print
+
+
+
+@code {
+ SfPdfViewer2 Viewer;
+ SfTextBox TextBox1;
+ SfTextBox TextBox2;
+ public string DocumentPath { get; set; } = "wwwroot/pdf-succinctly.pdf";
+
+ // Access the loaded PDF Viewer instance - Zoom functionality
+ public async void OnZoomClick(MouseEventArgs args)
+ {
+ int zoomValue = int.Parse(TextBox1.Value.ToString());
+ await Viewer.ZoomAsync(zoomValue);
+ }
+ // Navigate to a specific page
+ public async void OnPageClick(MouseEventArgs args)
+ {
+ int pageIndex = int.Parse(TextBox2.Value.ToString());
+ await Viewer.GoToPageAsync(pageIndex);
+ }
+
+ // Print the PDF document
+ public async void OnClick(MouseEventArgs args)
+ {
+ await Viewer.PrintAsync();
+ }
+
+ // Download the PDF document
+ public async void OnClickDownload(MouseEventArgs args)
+ {
+ await Viewer.DownloadAsync();
+ }
+}
+```
+
+## See also
+- [Blazor PDF Viewer –API Reference](https://help.syncfusion.com/cr/blazor/syncfusion.blazor.sfpdfviewer.sfpdfviewer2.html)
+- [Blazor FAQ](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/blazor/faq) (e.g., Magnification, Navigation, Print) — ensure the features you need are available
\ No newline at end of file