diff --git a/.github/workflows/conversion-production.yml b/.github/workflows/conversion-production.yml
new file mode 100644
index 0000000..6120cb2
--- /dev/null
+++ b/.github/workflows/conversion-production.yml
@@ -0,0 +1,69 @@
+# This is a basic workflow to help you get started with Actions
+
+name: tutorials.groupdocs.cloud(conversion)(family)(Production)
+
+# Controls when the action will run.
+on:
+ # Triggers the workflow on push or pull request events but only for the master branch
+ push:
+ branches: [ master ]
+ paths:
+ - 'content/conversion/**'
+ pull_request:
+ branches: [ master ]
+ paths:
+ - 'content/conversion/**'
+
+ # Allows you to run this workflow manually from the Actions tab
+ workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+ # This workflow contains a single job called "build"
+ build:
+ # The type of runner that the job will run on
+ runs-on: ubuntu-latest
+
+ # Steps represent a sequence of conversion that will be executed as part of the job
+ steps:
+ # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+ - name: Checkout
+ uses: actions/checkout@v2
+ with:
+ submodules: true # Fetch Hugo themes
+ fetch-depth: 0 # Fetch all history for .GitInfo and .Lastmod
+ - name: Checkout theme repo
+ uses: actions/checkout@main
+ with:
+ repository: groupdocs-cloud/tutorials-theme
+ token: ${{ secrets.REPO_TOKEN }}
+ fetch-depth: 0
+ path: themes/tutorials-theme
+ # Step 2 - Sets up the latest version of Hugo
+ - name: Setup Hugo
+ uses: peaceiris/actions-hugo@v2
+ with:
+ hugo-version: '0.135.0'
+ extended: true
+ - name: Install Dependicies1
+ run: npm install -D --save autoprefixer
+ - name: Install Dependicies2
+ run: npm install -D --save postcss-cli
+ # Also specifies the theme we want to use
+ - name: Build
+ run: hugo --configDir config/conversion --environment production --minify
+
+ - name: Deploy tutorials.groupdocs.cloud(conversion)(family)(Production) to S3
+ run: hugo --configDir config/conversion --environment production deploy --target "Production" --maxDeletes 0
+ env:
+ AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY }}
+ AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_ACCESS }}
+ # Invalidate Cloudfront
+ - name: invalidate
+ uses: chetan/invalidate-cloudfront-action@v2
+ env:
+ DISTRIBUTION: ${{ secrets.AWS_DISTRIBUTION_PROD }}
+ PATHS: /conversion/*
+ AWS_REGION: 'us-west-2'
+ AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY }}
+ AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_ACCESS }}
diff --git a/.github/workflows/conversion-staging.yml b/.github/workflows/conversion-staging.yml
new file mode 100644
index 0000000..ef57f89
--- /dev/null
+++ b/.github/workflows/conversion-staging.yml
@@ -0,0 +1,69 @@
+# This is a basic workflow to help you get started with Actions
+
+name: qa-tutorials.groupdocs.cloud(conversion)(family)(Stage)
+
+# Controls when the action will run.
+on:
+ # Triggers the workflow on push or pull request events but only for the master branch
+ push:
+ branches: [ staging ]
+ paths:
+ - 'content/conversion/**'
+ pull_request:
+ branches: [ staging ]
+ paths:
+ - 'content/conversion/**'
+
+ # Allows you to run this workflow manually from the Actions tab
+ workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+ # This workflow contains a single job called "build"
+ build:
+ # The type of runner that the job will run on
+ runs-on: ubuntu-latest
+
+ # Steps represent a sequence of conversion that will be executed as part of the job
+ steps:
+ # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+ - name: Checkout
+ uses: actions/checkout@v2
+ with:
+ submodules: true # Fetch Hugo themes
+ fetch-depth: 0 # Fetch all history for .GitInfo and .Lastmod
+ - name: Checkout theme repo
+ uses: actions/checkout@main
+ with:
+ repository: groupdocs-cloud/tutorials-theme
+ token: ${{ secrets.REPO_TOKEN }}
+ fetch-depth: 0
+ path: themes/tutorials-theme
+ # Step 2 - Sets up the latest version of Hugo
+ - name: Setup Hugo
+ uses: peaceiris/actions-hugo@v2
+ with:
+ hugo-version: '0.135.0'
+ extended: true
+ - name: Install Dependicies1
+ run: npm install -D --save autoprefixer
+ - name: Install Dependicies2
+ run: npm install -D --save postcss-cli
+ # Also specifies the theme we want to use
+ - name: Build
+ run: hugo --configDir config/conversion --environment staging --minify
+
+ - name: Deploy qa-tutorials.groupdocs.cloud(conversion)(family)(Stage) to S3
+ run: hugo --configDir config/conversion --environment staging deploy --target "Stage" --maxDeletes 0
+ env:
+ AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY }}
+ AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_ACCESS }}
+ # Invalidate Cloudfront
+ - name: invalidate
+ uses: chetan/invalidate-cloudfront-action@v2
+ env:
+ DISTRIBUTION: ${{ secrets.AWS_DISTRIBUTION }}
+ PATHS: /conversion/*
+ AWS_REGION: 'us-west-2'
+ AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY }}
+ AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_ACCESS }}
diff --git a/config/conversion/_default/config.toml b/config/conversion/_default/config.toml
new file mode 100644
index 0000000..8c2c842
--- /dev/null
+++ b/config/conversion/_default/config.toml
@@ -0,0 +1,150 @@
+baseURL = "/conversion"
+title = "GroupDocs Cloud Tutorials"
+staticdir = 'content/static'
+enableRobotsTXT = true
+enableGitInfo = true
+disableKinds = ["taxonomy", "taxonomyTerm", "page", "RSS"]
+
+# Hugo allows theme composition (and inheritance). The precedence is from left to right.
+theme = ["tutorials-theme"]
+
+[params.menu]
+zh = "groupdocscloud-zh"
+ru = "groupdocscloud-ru"
+ar = "groupdocscloud-ar"
+cs = "groupdocscloud-cs"
+de = "groupdocscloud-de"
+el = "groupdocscloud-el"
+es = "groupdocscloud-es"
+fr = "groupdocscloud-fr"
+hi = "groupdocscloud-hi"
+hu = "groupdocscloud-hu"
+id = "groupdocscloud-id"
+it = "groupdocscloud-it"
+ja = "groupdocscloud-ja"
+ko = "groupdocscloud-ko"
+nl = "groupdocscloud-nl"
+pl = "groupdocscloud-pl"
+pt = "groupdocscloud-pt"
+sv = "groupdocscloud-sv"
+th = "groupdocscloud-th"
+tr = "groupdocscloud-tr"
+vi = "groupdocscloud-vi"
+zh-hant = "groupdocscloud-zht"
+
+defaultContentLang = 'en'
+[languages]
+ [languages.en]
+ contentDir = 'content/conversion/english'
+ languageName = 'English'
+ languageCode = "en"
+ flag = "flag-us"
+ weight = 10
+
+ignoreFiles = ["(?i:readme.md)", '\.spin$']
+
+# Image processing configuration.
+[imaging]
+resampleFilter = "CatmullRom"
+quality = 75
+anchor = "smart"
+
+[services]
+[services.googleAnalytics]
+# Comment out the next line to disable GA tracking. Also disables the feature described in [params.ui.feedback].
+# id = "UA-00000000-0"
+
+[markup]
+ [markup.tableOfContents]
+ endLevel = 2
+ ordered = true
+ startLevel = 2
+ [markup.goldmark]
+ [markup.goldmark.renderer]
+ unsafe = true
+ [markup.highlight]
+ anchorLineNos = false
+ codeFences = true
+ guessSyntax = false
+ hl_Lines = ""
+ lineAnchors = ""
+ lineNoStart = 1
+ lineNos = false
+ lineNumbersInTable = true
+ noClasses = false
+ tabWidth = 4
+
+# Everything below this are Site Params
+
+[params]
+copyright = "The GroupDocs Cloud Authors"
+privacy_policy = "https://policies.google.com/privacy"
+topbar_search_active = false
+logo_rel_link = ""
+
+# Containerize Menu
+[params.containerize]
+menu = "groupdocscloud-en"
+
+[params.meta]
+msapplication_TileColor = "#2b5797"
+msapplication_config = "https://cms.admin.containerize.com/templates/groupdocscloud/images/browserconfig.xml"
+theme_color = "#ffffff"
+author = "GroupDocs Cloud"
+
+# Title of 404 page
+title_404_page = "404 - Page Not Found | GroupDocs Cloud Tutorials"
+
+# Open Grapgh settings
+title = "GroupDocs Cloud Tutorials"
+images = ["images/aspose-cloud-image-for-open-graph.jpg"]
+description = "REST APIs along with open-source SDKs that allow developers to enhance applications with the capability to display, annotate, convert, e-sign, merge, classify, compare & translate documents in the Cloud"
+
+
+# Set to true to disable breadcrumb navigation.
+breadcrumb_disable = false
+# Set to true to hide the sidebar search box (the top nav search box will still be displayed if search is enabled)
+sidebar_search_disable = true
+# Set to false if you don't want to display a logo (/assets/icons/logo.svg) in the top nav bar
+navbar_logo = false
+# Set to true to disable the About link in the site footer
+footer_about_disable = false
+
+
+[minify]
+ disableCSS = false
+ disableHTML = false
+ disableJS = false
+ disableJSON = false
+ disableSVG = false
+ disableXML = false
+ minifyOutput = true
+ [minify.tdewolff]
+ [minify.tdewolff.css]
+ decimals = -1
+ keepCSS2 = true
+ [minify.tdewolff.html]
+ keepConditionalComments = true
+ keepDefaultAttrVals = true
+ keepDocumentTags = true
+ keepEndTags = true
+ keepQuotes = false
+ keepWhitespace = false
+ [minify.tdewolff.js]
+ [minify.tdewolff.json]
+ [minify.tdewolff.svg]
+ decimals = -1
+ [minify.tdewolff.xml]
+ keepWhitespace = false
+
+[Taxonomies]
+
+[deployment]
+[[deployment.matchers]]
+# Set custom content type for /sitemap.xml
+#pattern = "^sitemap\\.xml$"
+#pattern = "^[a-z]\\.xml$"
+pattern = "^.+\\.(xml)$"
+contentType = "application/xml"
+gzip = true
+force = true
diff --git a/config/conversion/production/config.toml b/config/conversion/production/config.toml
new file mode 100644
index 0000000..0b00552
--- /dev/null
+++ b/config/conversion/production/config.toml
@@ -0,0 +1,9 @@
+baseURL = "https://tutorials.groupdocs.cloud/conversion"
+
+# Google Tag Manager settings
+[params.gtm]
+gtm_id = "GTM-T42TVBC"
+
+[[deployment.targets]]
+name = "Production"
+URL = "s3://tutorials.groupdocs.cloud/?prefix=conversion/®ion=us-west-2"
diff --git a/config/conversion/staging/config.toml b/config/conversion/staging/config.toml
new file mode 100644
index 0000000..e2732b1
--- /dev/null
+++ b/config/conversion/staging/config.toml
@@ -0,0 +1,8 @@
+baseURL = "https://qa-tutorials.groupdocs.cloud/conversion"
+
+[[deployment.targets]]
+name = "Stage"
+URL = "s3://qa-tutorials.groupdocs.cloud/?prefix=conversion /®ion=us-west-2"
+
+
+
diff --git a/content/conversion/english/_index.md b/content/conversion/english/_index.md
new file mode 100644
index 0000000..cde0f90
--- /dev/null
+++ b/content/conversion/english/_index.md
@@ -0,0 +1,118 @@
+---
+title: GroupDocs.Conversion Cloud Tutorials - Comprehensive Documentation for API Integration
+weight: 2
+description: Learn how to seamlessly integrate GroupDocs.Conversion Cloud API into your applications with detailed tutorials. Explore step-by-step guides on document conversion, authentication, storage management, and advanced features to enhance your project's capabilities.
+url: /conversion/
+---
+
+# GroupDocs.Conversion Cloud Tutorials
+
+## Introduction
+
+Welcome to the comprehensive tutorials for GroupDocs.Conversion Cloud. This guide provides detailed instructions and resources to help you integrate our powerful document conversion capabilities into your applications. Whether you're building web, desktop, or mobile applications, this guide will walk you through the process of implementing GroupDocs.Conversion Cloud API in your projects.
+
+## Getting Started
+
+### [Quick Start Guide Tutorials](/conversion/quick-start-guide/)
+Step-by-step tutorials for developers to learn how to convert documents using GroupDocs.Conversion Cloud API
+
+### [Advanced Features Tutorials](/conversion/advanced-features/)
+Step-by-step tutorials for developers to master advanced document conversion features using GroupDocs.Conversion Cloud API
+
+### [Data Organization Techniques Tutorials](/conversion/data-organization/)
+Learn essential document data organization techniques with our hands-on tutorials for GroupDocs.Conversion Cloud API
+
+### Prerequisites
+
+Before you begin using GroupDocs.Conversion Cloud, ensure you have:
+
+- A valid GroupDocs.Conversion Cloud subscription
+- Your Client ID and Client Secret for authentication
+- Basic understanding of RESTful APIs
+- Development environment set up for your preferred programming language
+
+### Authentication
+
+All API requests to GroupDocs.Conversion Cloud require authentication. Learn how to:
+
+- Generate authentication tokens
+- Implement token-based authentication in your application
+- Manage and refresh access tokens securely
+
+## Core Conversion Operations
+
+### Basic File Conversion
+
+Implement essential document conversion operations:
+
+- Convert files between supported formats
+- Configure conversion settings and options
+- Handle conversion responses and output files
+
+### Advanced Conversion Features
+
+Take advantage of advanced conversion capabilities:
+
+- Set conversion quality parameters
+- Apply watermarks and other document modifications
+- Convert specific pages or page ranges
+- Work with password-protected documents
+
+## Integration Guides
+
+### API Client Integration
+
+Implementation guides for various programming languages:
+
+- C# / .NET
+- Java
+- Python
+- PHP
+- Node.js
+- Ruby
+- Android
+- iOS
+
+### Working with Storage APIs
+
+Learn how to:
+
+- Upload files for conversion
+- Download converted documents
+- Manage temporary and persistent storage
+- Set up and use custom storage providers
+
+## Best Practices
+
+- Optimize API usage for performance
+- Implement error handling and retries
+- Scale your conversion operations
+- Ensure security in your implementation
+
+## Troubleshooting
+
+Common issues and solutions to help you diagnose and resolve problems:
+
+- API connection issues
+- Authentication errors
+- Conversion quality problems
+- Resource limitations and handling
+
+## API Reference
+
+- Complete endpoint documentation
+- Request and response examples
+- Parameter reference
+- Error code explanations
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We encourage your feedback and questions about these tutorials! Please use our [support forum](https://forum.groupdocs.cloud/c/conversion/11) if you need assistance or want to suggest improvements to our learning materials.
diff --git a/content/conversion/english/advanced-features/_index.md b/content/conversion/english/advanced-features/_index.md
new file mode 100644
index 0000000..fdcad6d
--- /dev/null
+++ b/content/conversion/english/advanced-features/_index.md
@@ -0,0 +1,88 @@
+---
+title: GroupDocs.Conversion Cloud API Document Advanced Features Tutorials
+description: Step-by-step tutorials for developers to master advanced document conversion features using GroupDocs.Conversion Cloud API
+url: /advanced-features/
+weight: 10
+---
+
+# Tutorials for GroupDocs.Conversion Cloud API Advanced Features
+
+Welcome to our hands-on tutorial series for developers looking to master the advanced features of GroupDocs.Conversion Cloud API. This comprehensive learning path will guide you from basic to advanced conversion capabilities, providing practical, real-world examples you can implement in your own applications.
+
+## Learning Path
+
+These tutorials are structured to build your knowledge progressively. We recommend following them in the order presented below, but you can also jump to specific topics based on your needs.
+
+### Common Conversion Operations
+
+- [Tutorial: How to Convert Specific Pages](/advanced-features/convert-specific-pages/) - Learn to selectively convert only certain pages from multi-page documents, ideal for extracting specific content.
+
+- [Tutorial: How to Add Watermarks During Conversion](/advanced-features/add-watermark/) - Master the process of adding text watermarks to documents during the conversion process.
+
+- [Tutorial: How to Use Custom Fonts in Document Conversion](/advanced-features/convert-using-custom-font/) - Learn to implement custom fonts during document conversion to maintain visual fidelity.
+
+- [Tutorial: Converting Documents to PDF Formats](/advanced-features/convert-to-pdf/) - Learn to convert various document types to PDF and PDF/A formats with security.
+
+### Format-Specific Conversion Tutorials
+
+- [Tutorial: Converting to PDF Formats](/advanced-features/convert-to-pdf-formats/) - Comprehensive guide to converting various document types to PDF with advanced options.
+
+- [Tutorial: Converting to Word Processing Formats](/advanced-features/convert-to-word-processing/) - Learn to convert documents to DOC, DOCX and other word processing formats.
+
+- [Tutorial: Converting to Spreadsheet Formats](/advanced-features/convert-to-spreadsheet/) - Master the conversion to Excel and other spreadsheet formats with precise control.
+
+- [Tutorial: Converting to Image Formats](/advanced-features/convert-to-image-formats/) - Learn techniques for high-quality document to image conversion.
+
+- [Tutorial: Converting to HTML Format](/advanced-features/convert-to-html/) - Detailed tutorial on converting documents to web-friendly HTML format.
+
+- [Tutorial: Converting to Text Formats](/advanced-features/convert-to-text/) - Guide to extracting plain text content from various document formats.
+
+- [Learn to Convert to Any Format](/advanced-features/convert-to-any-format/) - Master the universal conversion capabilities for any supported format
+
+- [Tutorial: Converting to Image Formats](/advanced-features/convert-to-images/) - Learn to convert documents to JPG, PNG, TIFF and other image formats.
+
+### Document-Specific Load Options Tutorials
+
+- [Tutorial: Working with CAD Document Conversion](/advanced-features/cad-conversion-options/) - Learn specialized techniques for converting CAD documents with precision.
+
+- [Tutorial: CSV Document Conversion with Custom Options](/advanced-features/csv-conversion-options/) - Master the handling of CSV files with various delimiter settings.
+
+- [Tutorial: Email Document Conversion Techniques](/advanced-features/email-conversion-options/) - Learn to convert email formats with control over headers, fields, and attachments.
+
+- [Tutorial: Working with OneNote Document Conversion](/advanced-features/onenote-conversion-options/) - Specialized tutorial for OneNote document conversion.
+
+- [Tutorial: PDF Document Conversion with Advanced Options](/advanced-features/pdf-conversion-options/) - In-depth guide to PDF conversion with annotation handling and security features.
+
+### Asynchronous Conversion Tutorials
+
+- [Tutorial: Implementing Asynchronous Document Conversion](/advanced-features/convert-document-async/) - Learn how to handle large documents effectively with asynchronous conversion.
+
+## Getting Started
+
+Each tutorial includes:
+
+- Clear learning objectives
+- Required prerequisites
+- Step-by-step implementation instructions
+- Complete code examples with explanations
+- Troubleshooting tips
+- Practice exercises to reinforce your learning
+
+Before starting these tutorials, ensure you have:
+
+1. A GroupDocs.Conversion Cloud API account ([create a free trial here](https://dashboard.groupdocs.cloud/#/apps))
+2. Your application's Client ID and Client Secret
+3. Basic familiarity with REST API concepts
+4. Development environment for your preferred programming language
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We're excited to help you master GroupDocs.Conversion Cloud API! If you have questions about any tutorial, please reach out through our [support forum](https://forum.groupdocs.cloud/c/conversion/11).
diff --git a/content/conversion/english/advanced-features/add-watermark/_index.md b/content/conversion/english/advanced-features/add-watermark/_index.md
new file mode 100644
index 0000000..fdef41b
--- /dev/null
+++ b/content/conversion/english/advanced-features/add-watermark/_index.md
@@ -0,0 +1,403 @@
+---
+title: How to Add Watermarks During Document Conversion Tutorial
+description: Learn to add text watermarks to documents during conversion with GroupDocs.Conversion Cloud API in this step-by-step developer tutorial.
+url: /advanced-features/add-watermark/
+weight: 20
+---
+
+# Tutorial: How to Add Watermarks During Document Conversion
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Add customizable text watermarks to documents during the conversion process
+- Control watermark appearance including color, size, and positioning
+- Set watermark as a background or foreground element
+- Implement watermarking across different document formats
+- Create different watermark styles for various business needs
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- A document to test watermarking (we'll use a DOCX file in this tutorial)
+
+## Why Add Watermarks During Conversion?
+
+Watermarks serve multiple purposes in document management:
+
+- Ownership Indication: Displaying company name or copyright information
+- Confidentiality: Marking documents as "Confidential" or "Draft"
+- Branding: Adding brand elements to distributed documents
+- Version Control: Marking document versions or review status
+- Security: Discouraging unauthorized sharing or reproduction
+
+Using GroupDocs.Conversion Cloud API, you can add these watermarks dynamically during the conversion process, saving you from having to modify the original documents.
+
+## Implementation Steps
+
+### Step 1: Set Up Your Development Environment
+
+First, ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 2: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, you need to authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+var configuration = new Configuration(MyAppSid, MyAppKey);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 3: Configure Watermark Options
+
+Now, let's set up the watermark options for the conversion process:
+
+```csharp
+// Create watermark options
+var watermark = new WatermarkOptions
+{
+ Text = "CONFIDENTIAL", // The watermark text
+ Color = "Red", // Color of the watermark text
+ Width = 100, // Width of the watermark
+ Height = 100, // Height of the watermark
+ Background = true // Set as background (true) or foreground (false)
+};
+```
+
+The watermark options allow you to customize:
+- Text: The content of the watermark
+- Color: The color name (like Red, Blue) or hex value
+- Width/Height: The dimensions of the watermark
+- Background: Whether it appears behind (true) or on top of (false) the document content
+
+### Step 4: Create Conversion Settings with Watermark
+
+Now we'll prepare the full conversion settings including the watermark:
+
+```csharp
+// Prepare convert settings with watermark
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ WatermarkOptions = watermark
+ },
+ OutputPath = "converted/with-watermark.pdf"
+};
+```
+
+### Step 5: Execute the Conversion Request
+
+Now, let's execute the conversion with our watermark settings:
+
+```csharp
+// Convert document with watermark
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted with watermark: " + response[0].Url);
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class AddWatermarkExample
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+ string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+
+ var configuration = new Configuration(MyAppSid, MyAppKey);
+
+ // Create necessary API instances
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Create watermark options
+ var watermark = new WatermarkOptions
+ {
+ Text = "CONFIDENTIAL",
+ Color = "Red",
+ Width = 100,
+ Height = 100,
+ Background = true
+ };
+
+ // Prepare convert settings with watermark
+ var settings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ WatermarkOptions = watermark
+ },
+ OutputPath = "converted/with-watermark.pdf"
+ };
+
+ // Convert document with watermark
+ var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+ Console.WriteLine("Document converted with watermark: " + response[0].Url);
+
+ // Example 2: Diagonal watermark with different color
+ var diagonalWatermark = new WatermarkOptions
+ {
+ Text = "DRAFT",
+ Color = "Blue",
+ Width = 150,
+ Height = 150,
+ Background = false // Display on top of content
+ };
+
+ var settings2 = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ WatermarkOptions = diagonalWatermark
+ },
+ OutputPath = "converted/with-draft-watermark.pdf"
+ };
+
+ var response2 = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings2));
+ Console.WriteLine("Document converted with draft watermark: " + response2[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception when calling ConvertApi: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API
+api = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Example 1: Create a red "CONFIDENTIAL" watermark
+ # Set up the watermark options
+ watermark = groupdocs_conversion_cloud.WatermarkOptions()
+ watermark.text = "CONFIDENTIAL"
+ watermark.color = "Red"
+ watermark.width = 100
+ watermark.height = 100
+ watermark.background = True # Set as background
+
+ # Configure conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "WordProcessing/sample.docx"
+ settings.format = "pdf"
+
+ # Create convert options with watermark
+ convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options.watermark_options = watermark
+ settings.convert_options = convert_options
+ settings.output_path = "converted/with-watermark.pdf"
+
+ # Execute conversion
+ result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings))
+ print(f"Document converted with CONFIDENTIAL watermark: {result[0].url}")
+
+ # Example 2: Create a blue "DRAFT" watermark as foreground
+ draft_watermark = groupdocs_conversion_cloud.WatermarkOptions()
+ draft_watermark.text = "DRAFT"
+ draft_watermark.color = "Blue"
+ draft_watermark.width = 150
+ draft_watermark.height = 150
+ draft_watermark.background = False # Set as foreground
+
+ # Configure conversion settings
+ settings2 = groupdocs_conversion_cloud.ConvertSettings()
+ settings2.file_path = "WordProcessing/sample.docx"
+ settings2.format = "pdf"
+
+ # Create convert options with watermark
+ convert_options2 = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options2.watermark_options = draft_watermark
+ settings2.convert_options = convert_options2
+ settings2.output_path = "converted/with-draft-watermark.pdf"
+
+ # Execute conversion
+ result2 = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings2))
+ print(f"Document converted with DRAFT watermark: {result2[0].url}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now use the token to add watermark during conversion
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'WordProcessing/sample.docx',
+ 'Format': 'pdf',
+ 'ConvertOptions': {
+ 'WatermarkOptions': {
+ 'Text': 'CONFIDENTIAL',
+ 'Color': 'Red',
+ 'Width': 100,
+ 'Height': 100,
+ 'Background': true
+ }
+ },
+ 'OutputPath': 'converted/with-watermark.pdf'
+}"
+```
+
+## Watermark Customization Examples
+
+### Example 1: Diagonal Copyright Notice
+
+```csharp
+// Create a diagonal copyright watermark
+var copyrightWatermark = new WatermarkOptions
+{
+ Text = "© 2023 My Company - All Rights Reserved",
+ Color = "Gray",
+ Width = 200,
+ Height = 70,
+ Background = true
+};
+```
+
+### Example 2: "DRAFT" Watermark
+
+```csharp
+// Create a prominent "DRAFT" watermark
+var draftWatermark = new WatermarkOptions
+{
+ Text = "DRAFT",
+ Color = "Red",
+ Width = 150,
+ Height = 150,
+ Background = false // Display on top of content
+};
+```
+
+### Example 3: Confidential Document Watermark
+
+```csharp
+// Create a "CONFIDENTIAL" watermark
+var confidentialWatermark = new WatermarkOptions
+{
+ Text = "CONFIDENTIAL",
+ Color = "#FF0000", // Using hex color code
+ Width = 100,
+ Height = 100,
+ Background = true
+};
+```
+
+## Troubleshooting Tips
+
+### Watermark Not Appearing
+Issue: The watermark is not visible in the converted document.Solution:
+- Check if the watermark color contrasts with the document background
+- Try setting `Background` to `false` to place the watermark above the content
+- Increase the watermark width and height values
+
+### Watermark Positioning
+Issue: Watermark is not positioned as expected.Solution: Currently, the API centers the watermark. If you need precise positioning, consider using the GroupDocs.Watermark product instead.
+
+### Format Compatibility
+Issue: Watermark doesn't appear in certain output formats.
+Solution: Not all formats support watermarking. PDF, image formats, and most document formats work best. Some plain text formats may not support watermarks.
+
+## Try It Yourself
+
+Now that you've learned how to add watermarks, try these exercises:
+
+1. Create a document with a diagonal "SAMPLE" watermark in a semi-transparent gray color
+2. Add a copyright notice to the bottom of each page
+3. Create a "For Review Only" watermark to appear on top of the content
+4. Experiment with different colors and sizes to find the most effective watermark style
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Add text watermarks to documents during conversion
+- Configure watermark appearance including text, color, size, and positioning
+- Choose between background and foreground watermarks
+- Implement watermarking in different programming languages
+- Apply different watermark styles for various business needs
+
+## Next Steps
+
+Now that you can add watermarks during conversion, you might want to explore:
+- [Tutorial: How to Convert Specific Pages](/advanced-features/convert-specific-pages/)
+- [Tutorial: Converting to PDF Formats](/advanced-features/convert-to-pdf-formats/)
+- [Tutorial: How to Use Custom Fonts in Document Conversion](/advanced-features/convert-using-custom-font/)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).
diff --git a/content/conversion/english/advanced-features/cad-conversion-options/_index.md b/content/conversion/english/advanced-features/cad-conversion-options/_index.md
new file mode 100644
index 0000000..47a289e
--- /dev/null
+++ b/content/conversion/english/advanced-features/cad-conversion-options/_index.md
@@ -0,0 +1,379 @@
+---
+url: /advanced-features/cad-conversion-options/
+title: Converting CAD Documents with Load Options in GroupDocs.Conversion Cloud API Tutorial
+description: Learn to convert CAD drawings and models to other formats with specialized options using GroupDocs.Conversion Cloud API
+weight: 40
+---
+
+# Tutorial: Converting CAD Documents with Load Options
+
+In this tutorial, you'll learn how to convert Computer-Aided Design (CAD) documents to various formats using GroupDocs.Conversion Cloud API. You'll master specialized conversion options for handling technical drawings and 3D models created in CAD applications like AutoCAD.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert CAD documents (DWG, DXF, etc.) to other formats like PDF and images
+- Customize CAD conversion with specialized load options
+- Control drawing dimensions, layouts, and layers
+- Implement both storage-based and stream-based CAD conversions
+- Troubleshoot common CAD conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample CAD documents to test conversion (we'll use DWG files in this tutorial)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic CAD to PDF Conversion
+
+Let's start with a simple conversion from a DWG file to PDF format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'cad/sample.dwg',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting CAD to PDF with Resolution and Size Options
+
+Now let's implement a comprehensive example that converts a CAD document to PDF with dimension control:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace CadConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from CAD to PDF with options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "cad/sample.dwg",
+ Format = "pdf",
+ // CAD-specific load options
+ LoadOptions = new CadLoadOptions()
+ {
+ // Set drawing dimensions
+ Width = 1920, // Width in pixels
+ Height = 1080, // Height in pixels
+
+ // Specify layout and layers
+ LayoutName = "Model", // Use Model space (default layout)
+
+ // Background color (optional)
+ BackgroundColor = "white"
+ },
+ // PDF-specific convert options
+ ConvertOptions = new PdfConvertOptions()
+ {
+ // PDF settings (if needed)
+ Dpi = 300, // High resolution for technical drawings
+ Width = 1920,
+ Height = 1080,
+ CenterWindow = true
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("CAD document converted successfully to PDF: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting CAD to Image Format
+
+Converting CAD documents to image formats is useful for web display or document embedding:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class CadToImageExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for CAD to PNG
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("cad/blueprint.dwg");
+ settings.setFormat("png");
+
+ // Set CAD-specific load options
+ CadLoadOptions loadOptions = new CadLoadOptions();
+ loadOptions.setWidth(2048); // Width in pixels
+ loadOptions.setHeight(1536); // Height in pixels
+ loadOptions.setLayoutName("Model"); // Use Model space
+ loadOptions.setDrawType("AfterRender"); // After render drawing mode
+ loadOptions.setBackgroundColor("lightblue"); // Background color
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure PNG-specific convert options
+ PngConvertOptions convertOptions = new PngConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(1); // Most CAD files have just one page
+ convertOptions.setDpi(300); // High resolution
+ convertOptions.setBackgroundColor("lightblue"); // Match background color
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("CAD document converted successfully to PNG: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting with Layout Selection
+
+CAD files often contain multiple layouts. Here's how to target a specific layout:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "cad/multilayout.dwg"
+ settings.format = "pdf"
+
+ # Configure CAD-specific load options
+ load_options = groupdocs_conversion_cloud.CadLoadOptions()
+ load_options.width = 2000 # Width in pixels
+ load_options.height = 1000 # Height in pixels
+ load_options.layout_name = "Layout1" # Specific named layout (not Model space)
+ load_options.background_color = "white"
+
+ settings.load_options = load_options
+
+ # Configure PDF-specific convert options
+ convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options.dpi = 300
+ convert_options.width = 2000
+ convert_options.height = 1000
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"CAD document converted successfully with layout '{load_options.layout_name}': {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based CAD Conversion
+
+For applications that need to process the converted CAD drawing directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "cad/sample.dwg",
+ format: "pdf",
+ loadOptions: {
+ // CAD-specific load options
+ width: 1920,
+ height: 1080,
+ layoutName: "Model",
+ backgroundColor: "white"
+ },
+ convertOptions: {
+ // PDF-specific convert options
+ dpi: 300,
+ width: 1920,
+ height: 1080
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-cad.pdf";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`CAD document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## CAD-Specific Load Options
+
+When converting CAD documents, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| Width | Width of the resulting drawing in pixels | Depends on CAD file | Affects output size and clarity |
+| Height | Height of the resulting drawing in pixels | Depends on CAD file | Affects output size and clarity |
+| LayoutName | Name of the layout to convert | "Model" | Selects specific layout from drawing |
+| DrawType | Drawing mode | Auto | Controls rendering technique |
+| BackgroundColor | Background color | Black | Affects appearance of transparent areas |
+| DrawColor | Drawing color for monochrome conversions | Black | Affects line colors in output |
+| Layers | Specific layers to include | All | Controls which layers are visible |
+
+## Troubleshooting Common Issues
+
+### 1. Dimensioning and Scaling Problems
+
+If the drawing dimensions don't look right:
+- Adjust Width and Height to maintain the correct aspect ratio
+- For technical drawings with fine details, use higher Width/Height values
+- Consider using the DrawType option to control how the CAD engine renders the drawing
+
+### 2. Layout Selection Challenges
+
+If you're having trouble with layouts:
+- Verify the layout name exists in the original CAD file
+- Use "Model" for the model space (default design area)
+- For paper space layouts, use the exact name as shown in the CAD program
+
+### 3. Layer Visibility Issues
+
+If certain elements are missing or unwanted:
+- Check if the elements are on specific layers
+- For selective conversion, specify only the layers you want to include
+- For complete drawings, leave the layers option unset to include all layers
+
+### 4. Color and Appearance Problems
+
+If colors don't appear as expected:
+- Set the BackgroundColor to match your needs (white for documents, transparent for web)
+- For monochrome drawings, use DrawColor to control the line color
+- If text or fine lines are hard to see, try adjusting the drawing colors for better contrast
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert CAD documents to PDF and image formats
+- Customizing CAD conversion settings for optimal results
+- Controlling drawing dimensions, layouts, and layers
+- Implementing both storage-based and stream-based CAD conversions
+- Troubleshooting common CAD conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a CAD viewer that converts drawings to web-friendly formats for display
+2. Implement a batch conversion utility that processes multiple CAD files with different layouts
+3. Build a service that extracts specific layouts from CAD files based on client requests
+4. Create a conversion tool that optimizes CAD drawings for different output purposes (print vs. web)
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting CSV Documents with Load Options](/advanced-features/csv-conversion-options) to master CSV parsing and conversion with customization.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-document-async/_index.md b/content/conversion/english/advanced-features/convert-document-async/_index.md
new file mode 100644
index 0000000..9fb3437
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-document-async/_index.md
@@ -0,0 +1,533 @@
+---
+title: Implementing Asynchronous Document Conversion Tutorial
+description: Learn how to implement asynchronous document conversion for handling large files efficiently with GroupDocs.Conversion Cloud API in this step-by-step developer tutorial.
+url: /advanced-features/convert-document-async/
+weight: 180
+---
+
+# Tutorial: Implementing Asynchronous Document Conversion
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Implement asynchronous document conversion for handling large files
+- Start conversion jobs that run in the background
+- Monitor conversion status and handle notifications
+- Retrieve conversion results when processing is complete
+- Structure your code for efficient asynchronous operations
+- Handle timeouts and errors in asynchronous processing
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts and asynchronous programming
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- Large documents to test async conversion (the benefits are more noticeable with larger files)
+
+## Why Use Asynchronous Conversion?
+
+Synchronous (direct) document conversion works well for smaller files, but has several limitations when working with larger documents:
+
+- Timeout issues: API calls may time out if the conversion takes too long
+- Connection problems: Extended connections are more vulnerable to network disruptions
+- Resource blocking: Your application can become unresponsive while waiting for conversion to complete
+- User experience: Users must wait for the entire process to finish before continuing
+
+Asynchronous conversion solves these problems by:
+- Starting the conversion process and immediately returning a job ID
+- Allowing your application to continue other operations
+- Providing a way to check conversion status
+- Enabling retrieval of results when the conversion is complete
+
+## Implementation Steps
+
+### Step 1: Set Up Your Development Environment
+
+First, ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 2: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, you need to authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+var configuration = new Configuration(MyClientId, MyClientSecret);
+
+// Create API instance for async operations
+var asyncApi = new AsyncApi(configuration);
+```
+
+### Step 3: Start an Asynchronous Conversion Job
+
+Now, let's initiate an asynchronous conversion process:
+
+```csharp
+// Prepare convert settings
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/large-document.docx",
+ Format = "pdf",
+ OutputPath = "converted/async-result.pdf"
+};
+
+// Start the conversion process asynchronously
+var operationId = asyncApi.StartConvertAndSave(new StartConvertAndSaveRequest(settings));
+
+Console.WriteLine("Operation started. ID: " + operationId);
+```
+
+This call initiates the conversion but doesn't wait for it to complete. Instead, it returns an operation ID that you can use to check the status later.
+
+### Step 4: Check Conversion Status
+
+After starting the conversion, you need to periodically check its status:
+
+```csharp
+// Check operation status
+bool isCompleted = false;
+while (!isCompleted)
+{
+ // Wait a bit before checking (don't poll too frequently)
+ Thread.Sleep(1000); // 1 second
+
+ // Get current status
+ var statusRequest = new GetOperationStatusRequest(operationId);
+ var statusResult = asyncApi.GetOperationStatus(statusRequest);
+
+ Console.WriteLine("Current status: " + statusResult.Status);
+
+ // Check if the operation has completed (either successfully or with an error)
+ if (statusResult.Status == OperationResult.StatusEnum.Finished)
+ {
+ Console.WriteLine("Conversion completed successfully!");
+ isCompleted = true;
+ }
+ else if (statusResult.Status == OperationResult.StatusEnum.Failed)
+ {
+ Console.WriteLine("Conversion failed: " + statusResult.Error);
+ isCompleted = true;
+ }
+ // Otherwise, the status is 'Processing', and we continue waiting
+}
+```
+
+### Step 5: Retrieve Conversion Results
+
+Once the conversion is complete, you can retrieve the results:
+
+```csharp
+// Get operation results
+if (statusResult.Status == OperationResult.StatusEnum.Finished)
+{
+ // Results are available in statusResult.Result
+ foreach (var file in statusResult.Result)
+ {
+ Console.WriteLine("Converted file: " + file.Name);
+ Console.WriteLine("File URL: " + file.Url);
+ }
+}
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using System.Threading;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class AsyncConversionExample
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+ string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+
+ // Create API instance for async operations
+ var asyncApi = new AsyncApi(configuration);
+
+ try
+ {
+ // Prepare convert settings
+ var settings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/large-document.docx",
+ Format = "pdf",
+ OutputPath = "converted/async-result.pdf"
+ };
+
+ // Start the conversion process asynchronously
+ var operationId = asyncApi.StartConvertAndSave(new StartConvertAndSaveRequest(settings));
+
+ Console.WriteLine("Operation started. ID: " + operationId);
+
+ // Check operation status
+ bool isCompleted = false;
+ OperationResult statusResult = null;
+
+ while (!isCompleted)
+ {
+ // Wait a bit before checking (don't poll too frequently)
+ Thread.Sleep(1000); // 1 second
+
+ // Get current status
+ var statusRequest = new GetOperationStatusRequest(operationId);
+ statusResult = asyncApi.GetOperationStatus(statusRequest);
+
+ Console.WriteLine("Current status: " + statusResult.Status);
+
+ // Check if the operation has completed (either successfully or with an error)
+ if (statusResult.Status == OperationResult.StatusEnum.Finished)
+ {
+ Console.WriteLine("Conversion completed successfully!");
+ isCompleted = true;
+ }
+ else if (statusResult.Status == OperationResult.StatusEnum.Failed)
+ {
+ Console.WriteLine("Conversion failed: " + statusResult.Error);
+ isCompleted = true;
+ }
+ // Otherwise, the status is 'Processing', and we continue waiting
+ }
+
+ // Get operation results
+ if (statusResult.Status == OperationResult.StatusEnum.Finished)
+ {
+ // Results are available in statusResult.Result
+ foreach (var file in statusResult.Result)
+ {
+ Console.WriteLine("Converted file: " + file.Name);
+ Console.WriteLine("File URL: " + file.Url);
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception during async operation: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import time
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API for async operations
+async_api = groupdocs_conversion_cloud.AsyncApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare convert settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "WordProcessing/large-document.docx"
+ settings.format = "pdf"
+ settings.output_path = "converted/async-result.pdf"
+
+ # Start the conversion process asynchronously
+ operation_id = async_api.start_convert_and_save(groupdocs_conversion_cloud.StartConvertAndSaveRequest(settings))
+
+ print(f"Operation started. ID: {operation_id}")
+
+ # Check operation status
+ is_completed = False
+ status_result = None
+
+ while not is_completed:
+ # Wait a bit before checking (don't poll too frequently)
+ time.sleep(1) # 1 second
+
+ # Get current status
+ status_request = groupdocs_conversion_cloud.GetOperationStatusRequest(operation_id)
+ status_result = async_api.get_operation_status(status_request)
+
+ print(f"Current status: {status_result.status}")
+
+ # Check if the operation has completed (either successfully or with an error)
+ if status_result.status == "Finished":
+ print("Conversion completed successfully!")
+ is_completed = True
+ elif status_result.status == "Failed":
+ print(f"Conversion failed: {status_result.error}")
+ is_completed = True
+ # Otherwise, the status is 'Processing', and we continue waiting
+
+ # Get operation results
+ if status_result.status == "Finished":
+ # Results are available in status_result.result
+ for file in status_result.result:
+ print(f"Converted file: {file.name}")
+ print(f"File URL: {file.url}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception during async operation: {e}")
+```
+
+### Using Java
+
+```java
+// Import required packages
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.api.AsyncApi;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class AsyncConversionExample {
+ public static void main(String[] args) {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ String clientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+ String clientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+
+ Configuration configuration = new Configuration(clientId, clientSecret);
+
+ // Create API instance for async operations
+ AsyncApi asyncApi = new AsyncApi(configuration);
+
+ try {
+ // Prepare convert settings
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("WordProcessing/large-document.docx");
+ settings.setFormat("pdf");
+ settings.setOutputPath("converted/async-result.pdf");
+
+ // Start the conversion process asynchronously
+ String operationId = asyncApi.startConvertAndSave(new StartConvertAndSaveRequest(settings));
+
+ System.out.println("Operation started. ID: " + operationId);
+
+ // Check operation status
+ boolean isCompleted = false;
+ OperationResult statusResult = null;
+
+ while (!isCompleted) {
+ // Wait a bit before checking (don't poll too frequently)
+ Thread.sleep(1000); // 1 second
+
+ // Get current status
+ GetOperationStatusRequest statusRequest = new GetOperationStatusRequest(operationId);
+ statusResult = asyncApi.getOperationStatus(statusRequest);
+
+ System.out.println("Current status: " + statusResult.getStatus());
+
+ // Check if the operation has completed (either successfully or with an error)
+ if (statusResult.getStatus() == OperationResult.StatusEnum.FINISHED) {
+ System.out.println("Conversion completed successfully!");
+ isCompleted = true;
+ }
+ else if (statusResult.getStatus() == OperationResult.StatusEnum.FAILED) {
+ System.out.println("Conversion failed: " + statusResult.getError());
+ isCompleted = true;
+ }
+ // Otherwise, the status is 'Processing', and we continue waiting
+ }
+
+ // Get operation results
+ if (statusResult.getStatus() == OperationResult.StatusEnum.FINISHED) {
+ // Results are available in statusResult.getResult()
+ List results = statusResult.getResult();
+ for (StoredConvertedResult file : results) {
+ System.out.println("Converted file: " + file.getName());
+ System.out.println("File URL: " + file.getUrl());
+ }
+ }
+ } catch (Exception e) {
+ System.err.println("Exception during async operation: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now start async conversion
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/async" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'WordProcessing/large-document.docx',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted/async-result.pdf'
+}"
+
+# You'll receive an operation ID in the response
+# Now check operation status
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/async/YOUR_OPERATION_ID/status" \
+-X GET \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN"
+
+# When status is "Finished", you can access your converted document at the OutputPath
+```
+
+## Best Practices for Asynchronous Conversion
+
+### 1. Implement Exponential Backoff
+
+Instead of checking status at fixed intervals, use exponential backoff to reduce API calls:
+
+```csharp
+int retryCount = 0;
+int maxRetries = 10;
+int delay = 1000; // Start with 1 second
+
+while (retryCount < maxRetries && !isCompleted)
+{
+ // Wait with increasing delay
+ Thread.Sleep(delay);
+ delay *= 2; // Double the delay each time
+
+ // Get current status and check as before...
+
+ retryCount++;
+}
+```
+
+### 2. Implement Webhook Callbacks
+
+For production applications, consider implementing webhook notifications instead of polling:
+
+```csharp
+// In your conversion request, include a webhook URL
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/large-document.docx",
+ Format = "pdf",
+ OutputPath = "converted/async-result.pdf",
+ // Note: Webhook functionality would need to be implemented on the server side
+};
+```
+
+### 3. Set Reasonable Timeouts
+
+Always implement a maximum wait time for your asynchronous operations:
+
+```csharp
+// Set a maximum wait time (e.g., 5 minutes)
+DateTime startTime = DateTime.Now;
+TimeSpan maxWaitTime = TimeSpan.FromMinutes(5);
+
+while (!isCompleted)
+{
+ // Check if we've exceeded the maximum wait time
+ if (DateTime.Now - startTime > maxWaitTime)
+ {
+ Console.WriteLine("Timeout: Conversion is taking too long");
+ break;
+ }
+
+ // Check status as before...
+}
+```
+
+## Troubleshooting Tips
+
+### Operation Not Found
+Issue: The API returns "Operation not found" when checking status.Solution: Verify that you're using the correct operation ID and that it hasn't expired. Operation IDs are typically valid for 24 hours.
+
+### Long-Running Conversions
+Issue: Very large documents take a long time to convert.Solution:
+- Ensure your polling mechanism has appropriate timeouts
+- Consider breaking large documents into smaller chunks if possible
+- For extremely large files, use optimized conversion settings
+
+### Error Handling
+Issue: How to handle conversion failures gracefully.Solution: Implement comprehensive error handling:
+
+```csharp
+if (statusResult.Status == OperationResult.StatusEnum.Failed)
+{
+ // Log detailed error information
+ Console.WriteLine("Conversion failed with error: " + statusResult.Error);
+
+ // Implement retry logic if appropriate
+ if (statusResult.Error.Contains("temporary"))
+ {
+ // Maybe retry the conversion
+ }
+
+ // Notify appropriate channels
+ // NotifyAdministrator(statusResult.Error);
+}
+```
+
+## Try It Yourself
+
+Now that you've learned about asynchronous conversion, try these exercises:
+
+1. Implement async conversion for a large document with progress reporting
+2. Add a timeout mechanism with appropriate error handling
+3. Compare performance between synchronous and asynchronous conversion
+4. Implement a simple webhook receiver to handle conversion notifications
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Implement asynchronous document conversion for handling large files
+- Start conversion jobs that run in the background
+- Monitor conversion status efficiently
+- Retrieve conversion results when processing is complete
+- Structure your code for robust asynchronous operations
+- Handle timeouts and errors in asynchronous processing
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).
\ No newline at end of file
diff --git a/content/conversion/english/advanced-features/convert-specific-pages/_index.md b/content/conversion/english/advanced-features/convert-specific-pages/_index.md
new file mode 100644
index 0000000..3240eb4
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-specific-pages/_index.md
@@ -0,0 +1,329 @@
+---
+title: How to Convert Specific Pages from Documents Tutorial
+description: Learn how to convert selected pages from documents using GroupDocs.Conversion Cloud API in this step-by-step developer tutorial.
+url: /advanced-features/convert-specific-pages/
+weight: 50
+---
+
+# Tutorial: How to Convert Specific Pages from Documents
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Selectively convert individual pages from multi-page documents
+- Specify non-consecutive pages for conversion
+- Implement page selection across different programming languages
+- Handle page numbering correctly in your conversion requests
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- A multi-page document to test the conversion (we'll use a DOCX file in this tutorial)
+
+## Understanding Page Selection in Document Conversion
+
+When working with multi-page documents, you often need to extract or convert only specific pages rather than the entire document. This capability is valuable for:
+
+- Extracting key information from large reports
+- Creating previews of selected document pages
+- Breaking down large documents into smaller segments
+- Focusing on relevant content for targeted processing
+
+In this tutorial, we'll demonstrate how to use GroupDocs.Conversion Cloud API to convert only selected pages from a document.
+
+## Implementation Steps
+
+### Step 1: Set Up Your Development Environment
+
+First, ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 2: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, you need to authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+var configuration = new Configuration(MyAppSid, MyAppKey);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 3: Upload Your Document
+
+Before conversion, upload your document to the cloud storage:
+
+```csharp
+// For this step, we're assuming the document is already uploaded
+// See the File API documentation for details on uploading files
+```
+
+### Step 4: Specify the Pages to Convert
+
+Now let's create a conversion request specifying only certain pages. There are two ways to select pages:
+
+#### Method 1: Using Pages Array (for non-consecutive pages)
+
+```csharp
+// Prepare convert settings
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ Pages = new List {1, 3} // Convert only pages 1 and 3 (page numbers start from 1)
+ },
+ OutputPath = "converted/selected-pages.pdf"
+};
+```
+
+#### Method 2: Using FromPage and PagesCount (for consecutive pages)
+
+```csharp
+// Prepare convert settings
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ FromPage = 2,
+ PagesCount = 2 // Convert pages 2 and 3
+ },
+ OutputPath = "converted/consecutive-pages.pdf"
+};
+```
+
+### Step 5: Send the Conversion Request
+
+Execute the conversion with your specified settings:
+
+```csharp
+// Convert to specified format
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted successfully: " + response[0].Url);
+```
+
+### Step 6: Download or Process the Result
+
+After conversion, you can either download the result or process it as needed:
+
+```csharp
+// The response contains the URL to access the converted document
+// You can download it using the storage API or access it directly via the URL
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class ConvertSpecificPages
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+ string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+
+ var configuration = new Configuration(MyAppSid, MyAppKey);
+
+ // Create necessary API instances
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Example 1: Convert non-consecutive pages (1 and 3)
+ var settings1 = new ConvertSettings
+ {
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ Pages = new List {1, 3} // Convert only pages 1 and 3
+ },
+ OutputPath = "converted/non-consecutive-pages.pdf"
+ };
+
+ // Convert to specified format
+ var response1 = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings1));
+ Console.WriteLine("Non-consecutive pages converted successfully: " + response1[0].Url);
+
+ // Example 2: Convert consecutive pages (2 and 3)
+ var settings2 = new ConvertSettings
+ {
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ ConvertOptions = new PdfConvertOptions
+ {
+ FromPage = 2,
+ PagesCount = 2 // Convert pages 2 and 3
+ },
+ OutputPath = "converted/consecutive-pages.pdf"
+ };
+
+ // Convert to specified format
+ var response2 = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings2));
+ Console.WriteLine("Consecutive pages converted successfully: " + response2[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception when calling ConvertApi: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API
+api = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Example 1: Convert non-consecutive pages (1 and 3)
+ settings1 = groupdocs_conversion_cloud.ConvertSettings()
+ settings1.file_path = "WordProcessing/four-pages.docx"
+ settings1.format = "pdf"
+
+ # Create convert options and specify pages
+ convert_options1 = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options1.pages = [1, 3] # Convert only pages 1 and 3
+
+ settings1.convert_options = convert_options1
+ settings1.output_path = "converted/non-consecutive-pages.pdf"
+
+ # Convert the document
+ result1 = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings1))
+ print(f"Non-consecutive pages converted successfully: {result1[0].url}")
+
+ # Example 2: Convert consecutive pages (2 and 3)
+ settings2 = groupdocs_conversion_cloud.ConvertSettings()
+ settings2.file_path = "WordProcessing/four-pages.docx"
+ settings2.format = "pdf"
+
+ # Create convert options for consecutive pages
+ convert_options2 = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options2.from_page = 2
+ convert_options2.pages_count = 2 # Convert pages 2 and 3
+
+ settings2.convert_options = convert_options2
+ settings2.output_path = "converted/consecutive-pages.pdf"
+
+ # Convert the document
+ result2 = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings2))
+ print(f"Consecutive pages converted successfully: {result2[0].url}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now use the token to convert specific pages
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'WordProcessing/four-pages.docx',
+ 'Format': 'pdf',
+ 'ConvertOptions': {
+ 'Pages': [1, 3]
+ },
+ 'OutputPath': 'converted/specific-pages.pdf'
+}"
+```
+
+## Troubleshooting Tips
+
+### Page Numbering
+Issue: Incorrect pages are being converted.Solution: Remember that page numbering starts from 1, not 0. If you need the first page, use 1 as the page number.
+
+### Invalid Page Numbers
+Issue: Error when specifying page numbers that don't exist.Solution: Ensure your page selection doesn't exceed the total number of pages in the document. The API will return an error if you request a non-existent page.
+
+### Format Compatibility
+Issue: Some formats might not support page-level operations.Solution: Not all document formats support page-level operations equally. For best results, use common document formats like DOCX, PDF, PPTX, etc.
+
+## Try It Yourself
+
+Now that you've learned how to convert specific pages, try these exercises:
+
+1. Convert the first and last pages of a 10-page document
+2. Extract pages 2-5 from a PDF document and convert them to JPG images
+3. Try converting specific pages from different document types (PDF, PPTX, etc.)
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Selectively convert specific pages from multi-page documents
+- Use two different methods for page selection (individual pages and page ranges)
+- Implement page selection in different programming languages
+- Handle common issues related to page-level conversion
+
+## Next Steps
+
+Now that you can convert specific pages, you might want to explore:
+- [Tutorial: How to Add Watermarks During Conversion](/advanced-features/add-watermark/)
+- [Tutorial: Converting to Image Formats](/advanced-features/convert-to-image-formats/)
+- [Tutorial: How to Use Custom Fonts in Document Conversion](/advanced-features/convert-using-custom-font/)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).
diff --git a/content/conversion/english/advanced-features/convert-to-any-format/_index.md b/content/conversion/english/advanced-features/convert-to-any-format/_index.md
new file mode 100644
index 0000000..3d0f5e3
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-any-format/_index.md
@@ -0,0 +1,353 @@
+---
+title: Learn to Convert to Any Format with GroupDocs.Conversion Cloud API
+description: Step-by-step tutorial on implementing universal document format conversions using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-any-format/
+weight: 180
+---
+
+# Tutorial: Converting to Any Format with GroupDocs.Conversion Cloud
+
+In this tutorial, you'll learn how to implement universal document conversion capabilities using GroupDocs.Conversion Cloud API. By the end, you'll be able to convert documents between multiple formats with customized settings and handle both storage-based and stream-based outputs.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Implement basic document conversion between any supported formats
+- Configure format-specific conversion options
+- Process conversion results as storage URLs and as direct streams
+- Handle conversion of password-protected documents
+- Troubleshoot common conversion issues
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use a Word document in this tutorial)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+If using an SDK, authentication is handled by configuring the client:
+
+```csharp
+// C# SDK example
+string clientId = "YOUR_CLIENT_ID";
+string clientSecret = "YOUR_CLIENT_SECRET";
+var configuration = new Configuration(clientId, clientSecret);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 2: Setting Up Basic Conversion Parameters
+
+Let's create a basic conversion request to convert a DOCX file to PDF:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Don't forget to replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Implementing Storage-Based Conversion
+
+Now let's implement a complete example that converts a document and saves the result to storage:
+
+#### Converting from Word to PDF
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ConversionTutorial
+{
+ class ConvertToAnyFormat
+ {
+ public static void ConvertDocumentToStorage()
+ {
+ // Configure the API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Specify conversion settings
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "pdf",
+ OutputPath = "converted"
+ };
+
+ // Convert to specified format
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Implementing Stream-Based Conversion
+
+For applications that need to process the converted file directly rather than saving it to storage:
+
+```csharp
+using System;
+using System.IO;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ConversionTutorial
+{
+ class ConvertToAnyFormat
+ {
+ public static void ConvertDocumentToStream()
+ {
+ // Configure the API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Specify conversion settings - note OutputPath is null for stream output
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "pdf",
+ // OutputPath = null indicates stream output
+ OutputPath = null
+ };
+
+ // Convert and get result as a stream
+ Stream response = apiInstance.ConvertDocumentDownload(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully, stream size: " +
+ response.Length.ToString() + " bytes");
+
+ // Process the stream as needed, for example, save to local file
+ using (var fileStream = File.Create("local-result.pdf"))
+ {
+ response.CopyTo(fileStream);
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 5: Advanced Conversion with Format-Specific Options
+
+Different target formats support specific conversion options. Here's how to use them:
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ConversionTutorial
+{
+ class ConvertToAnyFormat
+ {
+ public static void ConvertWithAdvancedOptions()
+ {
+ // Configure the API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Convert from DOCX to XLSX with specific options for Excel
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "xlsx",
+ ConvertOptions = new XlsxConvertOptions()
+ {
+ FromPage = 1,
+ PagesCount = 5,
+ Zoom = 150
+ },
+ OutputPath = "converted"
+ };
+
+ // Convert to specified format
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 6: Handling Password-Protected Documents
+
+For password-protected documents, you need to provide the password in the load options:
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ConversionTutorial
+{
+ class ConvertToAnyFormat
+ {
+ public static void ConvertProtectedDocument()
+ {
+ // Configure the API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Convert password-protected DOCX to PDF
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/protected.docx",
+ Format = "pdf",
+ // Specify password in load options
+ LoadOptions = new DocxLoadOptions()
+ {
+ Password = "mypassword"
+ },
+ OutputPath = "converted"
+ };
+
+ // Convert to specified format
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Protected document converted successfully: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+## Troubleshooting Common Issues
+
+### 1. Authentication Errors
+
+If you receive a 401 Unauthorized error, check:
+- Your Client ID and Client Secret are correctly entered
+- Your JWT token hasn't expired (tokens typically expire after 1 hour)
+- You're including the "Bearer " prefix before your token in the Authorization header
+
+### 2. File Not Found Errors
+
+If you get a file not found error:
+- Verify the file path is correct and the file exists in your storage
+- Check that the storage name parameter matches your actual storage name
+- Ensure you've uploaded the file to the storage before attempting conversion
+
+### 3. Conversion Failures
+
+If the conversion fails:
+- Verify the source document isn't corrupted
+- For protected documents, ensure the correct password is provided
+- Check that both source and target formats are supported
+- Review the specific error message for additional details
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to authenticate with GroupDocs.Conversion Cloud API
+- Basic document conversion to different formats
+- Stream-based and storage-based output handling
+- Implementing format-specific conversion options
+- Converting password-protected documents
+- Troubleshooting common conversion issues
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Convert a PDF document to a Word document (.docx)
+2. Implement a batch conversion that processes multiple files
+3. Create a simple web form that allows users to upload and convert documents
+4. Add error handling that provides user-friendly error messages for conversion issues
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting Documents to Spreadsheet Formats](/advanced-features/convert-to-spreadsheet/) to master specialized conversions to Excel and other spreadsheet formats.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-to-html/_index.md b/content/conversion/english/advanced-features/convert-to-html/_index.md
new file mode 100644
index 0000000..a14f6eb
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-html/_index.md
@@ -0,0 +1,398 @@
+---
+title: Converting to HTML Format with GroupDocs.Conversion Cloud API Tutorial
+description: Learn how to convert various document types to HTML with customization options for web publishing using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-html/
+weight: 90
+---
+
+# Tutorial: Converting to HTML Format
+
+In this tutorial, you'll learn how to convert various document types to HTML format using GroupDocs.Conversion Cloud API. You'll master web-friendly document conversions with options for responsive layouts, embedded resources, and display customizations.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to HTML format with various customization options
+- Control HTML layout and styling during conversion
+- Manage resource handling for embedded content
+- Implement responsive design considerations
+- Handle both storage-based and stream-based HTML conversions
+- Troubleshoot common HTML conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including Word, PDF, and PowerPoint)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic Document to HTML Conversion
+
+Let's start with a simple conversion from a Word document to HTML format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'html',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting to HTML with Layout Options
+
+Now let's implement a comprehensive example that converts a document to HTML with specific layout options:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace HtmlConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion to HTML with options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "html",
+ // For password-protected documents
+ LoadOptions = new DocxLoadOptions()
+ {
+ Password = ""
+ },
+ // HTML-specific convert options
+ ConvertOptions = new WebConvertOptions()
+ {
+ // Page selection
+ FromPage = 1,
+ PagesCount = 0, // All pages
+
+ // Layout options
+ FixedLayout = true, // Use fixed layout instead of fluid
+ FixedLayoutShowBorders = true, // Show page borders
+
+ // Resource handling
+ ResourcesEmbedded = true, // Embed resources (images, fonts)
+
+ // Output formatting
+ Zoom = 100, // Default zoom level
+
+ // Navigation options
+ UsePdf = false // Direct conversion (not via PDF)
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully to HTML: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting PDF to Responsive HTML
+
+PDF documents often need special handling to convert to responsive HTML:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class PdfToHtmlExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/sample.pdf");
+ settings.setFormat("html");
+
+ // Set PDF-specific load options
+ PdfLoadOptions loadOptions = new PdfLoadOptions();
+ loadOptions.setPassword(""); // If PDF is protected
+ loadOptions.setRemoveEmbeddedFiles(true); // Remove embedded files for cleaner output
+ loadOptions.setHidePdfAnnotations(true); // Hide annotations
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure HTML-specific convert options for responsive layout
+ WebConvertOptions convertOptions = new WebConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(0); // All pages
+
+ // Use fluid layout (not fixed) for responsive design
+ convertOptions.setFixedLayout(false);
+
+ // Additional options
+ convertOptions.setResourcesEmbedded(true); // Keep resources embedded
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("PDF converted successfully to responsive HTML: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting Presentations to HTML
+
+PowerPoint and other presentation formats often contain complex slides that need special handling:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/presentation.pptx"
+ settings.format = "html"
+
+ # Configure presentation-specific load options
+ load_options = groupdocs_conversion_cloud.PresentationLoadOptions()
+ load_options.show_hidden_slides = False # Skip hidden slides
+ load_options.password = "" # If presentation is protected
+
+ settings.load_options = load_options
+
+ # Configure HTML-specific convert options
+ convert_options = groupdocs_conversion_cloud.WebConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 0 # All slides
+
+ # Layout options - fixed is often better for presentations to preserve slide layout
+ convert_options.fixed_layout = True
+ convert_options.fixed_layout_show_borders = False # No borders around slides
+
+ # Resource handling - embed everything for standalone HTML
+ convert_options.resources_embedded = True
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Presentation converted successfully to HTML: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based HTML Conversion
+
+For applications that need to process the converted HTML directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.docx",
+ format: "html",
+ loadOptions: {
+ // DOCX-specific load options if needed
+ },
+ convertOptions: {
+ // HTML-specific convert options
+ fromPage: 1,
+ pagesCount: 0, // All pages
+ fixedLayout: false, // Fluid layout for responsive design
+ resourcesEmbedded: true // Embed all resources
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-document.html";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`Document converted and saved to ${fileName}`);
+
+ // Read the HTML to demonstrate we have it
+ fs.readFile(fileName, 'utf8', (err, data) => {
+ if (err) {
+ console.error("Error reading HTML file:", err);
+ return;
+ }
+
+ // Display the first 100 characters of the HTML
+ console.log("HTML Preview: " + data.substring(0, 100) + "...");
+ });
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## HTML-Specific Conversion Options
+
+When converting to HTML format, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| FromPage | First page number to convert | 1 | Controls starting page/slide |
+| PagesCount | Number of pages to convert | All | Limits content amount |
+| FixedLayout | Use fixed layout instead of fluid | false | Affects responsiveness |
+| FixedLayoutShowBorders | Show page borders in fixed layout | false | Visual appearance |
+| ResourcesEmbedded | Embed resources (images, fonts) | false | File independence |
+| Zoom | Default zoom level (%) | 100 | Initial display size |
+| UsePdf | Use PDF as intermediate format | false | Can improve complex layouts |
+
+## Troubleshooting Common Issues
+
+### 1. Layout and Responsiveness Issues
+
+If the converted HTML doesn't display correctly across devices:
+- For responsive design, set `FixedLayout` to false
+- For preserving exact layout (like presentations), set `FixedLayout` to true
+- If content appears too small or large, adjust the `Zoom` parameter
+
+### 2. Resource Handling Problems
+
+If images, fonts, or other resources are missing:
+- Set `ResourcesEmbedded` to true to include all resources in the HTML
+- Check if the original document has links to external resources that might be unavailable
+- For documents with custom fonts, ensure these fonts are available in the conversion environment
+
+### 3. Complex Layout Conversion Challenges
+
+For documents with complex layouts:
+- Try setting `UsePdf` to true, which may preserve complex layouts better
+- For tables, charts, and other complex elements, fixed layout often works better
+- If only part of the document has complex layouts, consider converting specific pages
+
+### 4. File Size Concerns
+
+If the HTML output is too large:
+- Consider setting `ResourcesEmbedded` to false and manage resources separately
+- For multi-page documents, convert pages in batches
+- Check if original documents contain high-resolution images that could be optimized
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to HTML
+- Controlling HTML layout options for different display requirements
+- Managing embedded resources for standalone or externally-referenced content
+- Implementing responsive design considerations for web viewing
+- Handling both storage-based and stream-based HTML conversions
+- Troubleshooting common HTML conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a document viewer web application that converts and displays documents as HTML
+2. Implement a batch conversion utility that processes multiple documents to responsive HTML
+3. Build a service that optimizes HTML output for mobile devices by adjusting layout options
+4. Create a comparison tool that shows different HTML conversion options side by side
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting to Text Format](/advanced-features/convert-to-text) to master text extraction and conversion from various document types.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
\ No newline at end of file
diff --git a/content/conversion/english/advanced-features/convert-to-image-formats/_index.md b/content/conversion/english/advanced-features/convert-to-image-formats/_index.md
new file mode 100644
index 0000000..b0e8cad
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-image-formats/_index.md
@@ -0,0 +1,596 @@
+---
+title: Converting Documents to Image Formats Tutorial
+description: Learn how to convert documents to various image formats with advanced customization options using GroupDocs.Conversion Cloud API in this comprehensive developer tutorial.
+url: /advanced-features/convert-to-image-formats/
+weight: 80
+---
+
+# Tutorial: Converting Documents to Image Formats
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Convert documents to various image formats (JPG, PNG, TIFF, etc.)
+- Configure image output quality, resolution, and color options
+- Control image dimensions and compression settings
+- Apply rotation and other visual transformations
+- Convert multi-page documents to individual image files
+- Implement image conversion across different programming languages
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- Source documents for conversion (PDF, DOCX, PPTX, etc.)
+
+## Why Convert Documents to Images?
+
+Converting documents to image formats serves numerous practical purposes:
+
+- Universal Compatibility: Images can be viewed on virtually any device without special software
+- Web Display: Easily embed document content in websites or applications
+- Printing and Sharing: Simplify document sharing across platforms
+- Content Protection: Prevent editing or copying of sensitive text
+- Thumbnail Generation: Create preview images of documents
+- Social Media Content: Create image posts from document content
+- Visual Archives: Store document appearance exactly as rendered
+
+GroupDocs.Conversion Cloud API provides powerful capabilities to convert documents to various image formats with precise control over the output quality and appearance.
+
+## Understanding Image Format Options
+
+Before diving into implementation, let's understand the key image formats and their use cases:
+
+| Format | Best For | Characteristics |
+|--------|----------|-----------------|
+| JPG/JPEG | Photographs, complex graphics | Lossy compression, smaller file size |
+| PNG | Screenshots, diagrams, text-heavy content | Lossless compression, transparency support |
+| TIFF | Professional publishing, archiving | Multiple compression options, multi-page support |
+| BMP | Uncompressed image storage | Perfect quality, large file size |
+| GIF | Simple animations, simple graphics | Limited colors, animation support |
+| WebP | Web optimization | Smaller than JPEG with similar quality |
+
+## Implementation Steps
+
+### Step 1: Set Up Your Development Environment
+
+First, ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 2: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, you need to authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+var configuration = new Configuration(MyClientId, MyClientSecret);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 3: Basic Image Conversion
+
+Let's start with a basic document to JPG conversion:
+
+```csharp
+// Basic conversion to JPG
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "jpg",
+ OutputPath = "converted/image-output"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted to JPG: " + response[0].Url);
+```
+
+When converting multi-page documents to image formats, the API will create separate image files for each page by default, with names like `sample-page-1.jpg`, `sample-page-2.jpg`, etc.
+
+### Step 4: Advanced Image Conversion Options
+
+Now, let's explore advanced options for image conversion:
+
+```csharp
+// Advanced JPG conversion with options
+var jpgOptions = new JpgConvertOptions
+{
+ // Image quality settings
+ Quality = 90, // JPEG quality (0-100)
+
+ // Resolution settings
+ Dpi = 300, // Dots per inch
+
+ // Color settings
+ Grayscale = false, // Color or grayscale
+
+ // Transformation settings
+ RotateAngle = 0, // Rotation angle in degrees
+
+ // Dimension settings
+ Width = 1920, // Width in pixels
+ Height = 1080, // Height in pixels
+
+ // Page settings
+ FromPage = 1, // Start page
+ PagesCount = 2, // Number of pages to convert
+
+ // Rendering settings
+ UsePdf = true // Use PDF as an intermediate format for better quality
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "jpg",
+ ConvertOptions = jpgOptions,
+ OutputPath = "converted/advanced-image-output"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+```
+
+Let's understand some key options:
+
+- Quality: Controls compression level for JPG (lower values = smaller files but lower quality)
+- Dpi: Dots per inch, affecting image resolution and clarity
+- Grayscale: Converts to black and white when true
+- RotateAngle: Rotates the image by specified degrees
+- Width/Height: Controls image dimensions
+- FromPage/PagesCount: Controls which pages to convert
+- UsePdf: When true, converts document to PDF first, which often improves quality
+
+### Step 5: Converting to PNG with Transparency
+
+For PNG conversion with transparency support:
+
+```csharp
+// PNG conversion with background color
+var pngOptions = new PngConvertOptions
+{
+ BackgroundColor = "transparent", // Transparent background
+ // Other options similar to JPG
+ Dpi = 300,
+ FromPage = 1,
+ PagesCount = 1,
+ Width = 800,
+ Height = 600
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "Presentation/sample.pptx",
+ Format = "png",
+ ConvertOptions = pngOptions,
+ OutputPath = "converted/png-output"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+```
+
+### Step 6: Converting to Multi-Page TIFF
+
+TIFF is unique in that it supports multi-page images in a single file:
+
+```csharp
+// Multi-page TIFF conversion
+var tiffOptions = new TiffConvertOptions
+{
+ Dpi = 300,
+ Width = 1200,
+ Height = 1800,
+ // TIFF compression options
+ Compression = "CCITT4" // Options include: "CCITT3", "CCITT4", "LZW", "None", "RLE"
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/multipage.docx",
+ Format = "tiff",
+ ConvertOptions = tiffOptions,
+ OutputPath = "converted/multipage-output.tiff"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class ConvertToImageExample
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+ string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+
+ // Create necessary API instances
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Example 1: Basic JPG conversion
+ var basicSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "jpg",
+ OutputPath = "converted/basic-jpg-output"
+ };
+
+ var basicResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(basicSettings));
+ Console.WriteLine("Basic JPG conversion completed: " + basicResponse[0].Url);
+
+ // Example 2: High-quality JPG with custom settings
+ var jpgOptions = new JpgConvertOptions
+ {
+ Quality = 95,
+ Dpi = 300,
+ Width = 1920,
+ Height = 1080,
+ UsePdf = true
+ };
+
+ var highQualitySettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "jpg",
+ ConvertOptions = jpgOptions,
+ OutputPath = "converted/high-quality-jpg-output"
+ };
+
+ var highQualityResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(highQualitySettings));
+ Console.WriteLine("High-quality JPG conversion completed");
+
+ // Example 3: Grayscale conversion
+ var grayscaleOptions = new JpgConvertOptions
+ {
+ Grayscale = true,
+ Dpi = 300
+ };
+
+ var grayscaleSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "jpg",
+ ConvertOptions = grayscaleOptions,
+ OutputPath = "converted/grayscale-output"
+ };
+
+ var grayscaleResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(grayscaleSettings));
+ Console.WriteLine("Grayscale conversion completed");
+
+ // Example 4: PNG with transparency
+ var pngOptions = new PngConvertOptions
+ {
+ BackgroundColor = "transparent",
+ Dpi = 300
+ };
+
+ var pngSettings = new ConvertSettings
+ {
+ FilePath = "Presentation/sample.pptx",
+ Format = "png",
+ ConvertOptions = pngOptions,
+ OutputPath = "converted/transparent-png-output"
+ };
+
+ var pngResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(pngSettings));
+ Console.WriteLine("PNG conversion with transparency completed");
+
+ // Example 5: Multi-page TIFF
+ var tiffOptions = new TiffConvertOptions
+ {
+ Dpi = 300,
+ Compression = "LZW"
+ };
+
+ var tiffSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/multipage.docx",
+ Format = "tiff",
+ ConvertOptions = tiffOptions,
+ OutputPath = "converted/multipage-tiff-output.tiff"
+ };
+
+ var tiffResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(tiffSettings));
+ Console.WriteLine("Multi-page TIFF conversion completed");
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception when calling ConvertApi: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API
+api = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Example 1: Basic JPG conversion
+ basic_settings = groupdocs_conversion_cloud.ConvertSettings()
+ basic_settings.file_path = "WordProcessing/sample.docx"
+ basic_settings.format = "jpg"
+ basic_settings.output_path = "converted/basic-jpg-output"
+
+ basic_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(basic_settings))
+ print(f"Basic JPG conversion completed: {basic_result[0].url}")
+
+ # Example 2: High-quality JPG with custom settings
+ jpg_options = groupdocs_conversion_cloud.JpgConvertOptions()
+ jpg_options.quality = 95
+ jpg_options.dpi = 300
+ jpg_options.width = 1920
+ jpg_options.height = 1080
+ jpg_options.use_pdf = True
+
+ high_quality_settings = groupdocs_conversion_cloud.ConvertSettings()
+ high_quality_settings.file_path = "WordProcessing/sample.docx"
+ high_quality_settings.format = "jpg"
+ high_quality_settings.convert_options = jpg_options
+ high_quality_settings.output_path = "converted/high-quality-jpg-output"
+
+ high_quality_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(high_quality_settings))
+ print("High-quality JPG conversion completed")
+
+ # Example 3: Grayscale conversion
+ grayscale_options = groupdocs_conversion_cloud.JpgConvertOptions()
+ grayscale_options.grayscale = True
+ grayscale_options.dpi = 300
+
+ grayscale_settings = groupdocs_conversion_cloud.ConvertSettings()
+ grayscale_settings.file_path = "WordProcessing/sample.docx"
+ grayscale_settings.format = "jpg"
+ grayscale_settings.convert_options = grayscale_options
+ grayscale_settings.output_path = "converted/grayscale-output"
+
+ grayscale_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(grayscale_settings))
+ print("Grayscale conversion completed")
+
+ # Example 4: PNG with transparency
+ png_options = groupdocs_conversion_cloud.PngConvertOptions()
+ png_options.background_color = "transparent"
+ png_options.dpi = 300
+
+ png_settings = groupdocs_conversion_cloud.ConvertSettings()
+ png_settings.file_path = "Presentation/sample.pptx"
+ png_settings.format = "png"
+ png_settings.convert_options = png_options
+ png_settings.output_path = "converted/transparent-png-output"
+
+ png_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(png_settings))
+ print("PNG conversion with transparency completed")
+
+ # Example 5: Multi-page TIFF
+ tiff_options = groupdocs_conversion_cloud.TiffConvertOptions()
+ tiff_options.dpi = 300
+ tiff_options.compression = "LZW"
+
+ tiff_settings = groupdocs_conversion_cloud.ConvertSettings()
+ tiff_settings.file_path = "WordProcessing/multipage.docx"
+ tiff_settings.format = "tiff"
+ tiff_settings.convert_options = tiff_options
+ tiff_settings.output_path = "converted/multipage-tiff-output.tiff"
+
+ tiff_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(tiff_settings))
+ print("Multi-page TIFF conversion completed")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now use the token to convert document to JPG with advanced options
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'WordProcessing/sample.docx',
+ 'Format': 'jpg',
+ 'ConvertOptions': {
+ 'Dpi': 300,
+ 'Width': 1920,
+ 'Height': 1080,
+ 'Quality': 95,
+ 'RotateAngle': 0,
+ 'UsePdf': true,
+ 'Grayscale': false
+ },
+ 'OutputPath': 'converted/image-output'
+}"
+```
+
+## Image Conversion Use Cases
+
+### Use Case 1: Document Thumbnails for Web Applications
+
+To generate small preview thumbnails of documents:
+
+```csharp
+var thumbnailOptions = new JpgConvertOptions
+{
+ Width = 240, // Small thumbnail width
+ Height = 320, // Small thumbnail height
+ Quality = 85, // Good quality, reasonable size
+ Dpi = 96, // Standard screen resolution
+ FromPage = 1, // Only the first page
+ PagesCount = 1 // Just one page
+};
+```
+
+### Use Case 2: High-Resolution Images for Printing
+
+For creating high-resolution images suitable for printing:
+
+```csharp
+var printOptions = new TiffConvertOptions
+{
+ Dpi = 600, // High resolution for printing
+ Quality = 100, // Maximum quality
+ Compression = "LZW", // Lossless compression
+ Grayscale = false // Keep color information
+};
+```
+
+### Use Case 3: Social Media Image Content
+
+For creating images optimized for social media posts:
+
+```csharp
+var socialMediaOptions = new JpgConvertOptions
+{
+ Width = 1200, // Optimal width for many platforms
+ Height = 630, // Optimal height for many platforms
+ Quality = 90, // High quality but optimized
+ Dpi = 96, // Standard screen resolution
+ UsePdf = true // Better quality rendering
+};
+```
+
+## Advanced Image Setting Explanations
+
+### Quality vs. File Size
+
+The Quality setting for JPG (0-100) has a significant impact on file size:
+
+- 90-100: Excellent quality, but larger files
+- 70-89: Good quality, reasonable file sizes
+- 50-69: Noticeable compression artifacts, small files
+- Below 50: Poor quality, very small files
+
+Choose based on your specific needs - higher for important visuals, lower for thumbnails or web optimization.
+
+### DPI and Resolution
+
+DPI (Dots Per Inch) affects the image clarity:
+
+- 72-96 DPI: Standard for screen display
+- 150-200 DPI: Good for general printing
+- 300+ DPI: High-quality printing and publishing
+
+Higher DPI creates larger files but provides better detail, especially when the image will be enlarged.
+
+### TIFF Compression Options
+
+TIFF supports various compression methods:
+
+- LZW: Lossless compression, good general-purpose choice
+- CCITT3/CCITT4: Best for black and white documents
+- RLE: Simple compression best for images with large areas of solid color
+- None: No compression, highest quality but largest file size
+
+## Troubleshooting Tips
+
+### Image Quality Issues
+Issue: Output images appear blurry or pixelated.Solution:
+- Increase the DPI setting (e.g., to 300 or higher)
+- For JPG format, increase the Quality setting (to 90+)
+- Consider using the `UsePdf = true` option for better rendering
+- Make sure Width/Height settings maintain the proper aspect ratio
+
+### File Size Problems
+Issue: Output image files are too large.Solution:
+- For JPG, reduce the Quality setting (try 70-80 for a good balance)
+- Lower the DPI if high resolution isn't necessary
+- For color images that don't need color, use `Grayscale = true`
+- Consider using appropriate compression settings for TIFF files
+
+### Rotation Issues
+Issue: Images are rotated incorrectly.Solution:
+- Use the `RotateAngle` property to specify rotation in degrees
+- Try common values: 90, 180, or 270 for portrait/landscape adjustments
+
+## Try It Yourself
+
+Now that you've learned about image conversion options, try these exercises:
+
+1. Convert a PDF document to high-quality PNG images
+2. Create thumbnail images of the first pages of multiple documents
+3. Convert a colorful document to grayscale JPEG with various quality settings
+4. Create a multi-page TIFF with different compression options and compare results
+5. Experiment with different DPI settings to understand the quality/size tradeoff
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Convert documents to various image formats using GroupDocs.Conversion Cloud API
+- Configure image output quality, resolution, and color options
+- Control image dimensions and compression settings
+- Apply rotation and other visual transformations
+- Convert multi-page documents to individual image files
+- Optimize image outputs for different use cases
+- Troubleshoot common image conversion issues
+
+## Next Steps
+
+Now that you can convert documents to images, you might want to explore:
+- [Tutorial: How to Add Watermarks During Conversion](/advanced-features/add-watermark/)
+- [Tutorial: Converting to PDF Formats](/advanced-features/convert-to-pdf-formats/)
+- [Tutorial: How to Convert Specific Pages](/advanced-features/convert-specific-pages/)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).
\ No newline at end of file
diff --git a/content/conversion/english/advanced-features/convert-to-images/_index.md b/content/conversion/english/advanced-features/convert-to-images/_index.md
new file mode 100644
index 0000000..7588234
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-images/_index.md
@@ -0,0 +1,399 @@
+---
+title: Converting to Image Formats with GroupDocs.Conversion Cloud API Tutorial
+description: Learn to convert documents to JPG, PNG, TIFF and other image formats with customization options using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-images/
+weight: 190
+---
+
+# Tutorial: Converting to Image Formats
+
+In this tutorial, you'll learn how to convert various document types to image formats using GroupDocs.Conversion Cloud API. You'll master conversions to JPG, PNG, TIFF, and other image formats with full control over image quality, resolution, and other parameters.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to various image formats (JPG, PNG, TIFF, BMP, etc.)
+- Customize image conversion options including quality, resolution, and color settings
+- Implement multi-page document conversion with page control
+- Handle both storage-based and stream-based image conversions
+- Troubleshoot common image conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including PDF and Word)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic Document to Image Conversion
+
+Let's start with a basic conversion from a Word document to JPG format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'jpg',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Don't forget to replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+The response will contain URLs to the converted image files (one per page):
+
+```json
+[
+ {
+ "name": "sample-page-1.jpg",
+ "size": 107611,
+ "url": "MyStorage:converted/sample-page-1.jpg"
+ },
+ {
+ "name": "sample-page-2.jpg",
+ "size": 45075,
+ "url": "MyStorage:converted/sample-page-2.jpg"
+ }
+]
+```
+
+### Step 3: Converting to JPG with Quality and Color Options
+
+Now let's implement a complete example that converts a document to JPG with specific image conversion options:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ImageConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from DOCX to JPG with options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "jpg",
+ // For password-protected documents
+ LoadOptions = new DocxLoadOptions() { Password = "" },
+ // JPG-specific convert options
+ ConvertOptions = new JpegConvertOptions()
+ {
+ FromPage = 1, // Start from first page
+ PagesCount = 2, // Convert first two pages
+ Quality = 100, // Maximum quality (1-100)
+ Grayscale = false, // Color image (not grayscale)
+ RotateAngle = 0, // No rotation
+ UsePdf = false, // Direct conversion (not via PDF)
+ Dpi = 300 // 300 DPI resolution
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully to images: " + response.Count);
+ foreach (var image in response)
+ {
+ Console.WriteLine(" - " + image.Name + " (" + image.Size + " bytes)");
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting to PNG with Background Color Setting
+
+PNG is ideal for documents with transparency or when lossless compression is required:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class DocumentToPngExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/sample.pdf");
+ settings.setFormat("png");
+
+ // Set PDF-specific load options if needed
+ PdfLoadOptions loadOptions = new PdfLoadOptions();
+ loadOptions.setPassword(""); // If PDF is protected
+ settings.setLoadOptions(loadOptions);
+
+ // Configure PNG-specific convert options
+ PngConvertOptions convertOptions = new PngConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(3);
+ convertOptions.setDpi(300);
+ convertOptions.setBackgroundColor("white"); // Set background color
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Document converted successfully to PNG: " + result.size() + " images");
+ for (StoredConvertedResult image : result) {
+ System.out.println(" - " + image.getName() + " (" + image.getSize() + " bytes)");
+ }
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting to TIFF (Multi-page Image)
+
+TIFF is useful when you want to store multiple pages in a single image file:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/multipage.pdf"
+ settings.format = "tiff"
+
+ # Configure PDF-specific load options
+ load_options = groupdocs_conversion_cloud.PdfLoadOptions()
+ load_options.password = "" # If PDF is protected
+
+ settings.load_options = load_options
+
+ # Configure TIFF-specific convert options
+ convert_options = groupdocs_conversion_cloud.TiffConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 5
+ convert_options.dpi = 200
+ convert_options.width = 1200 # Specify width in pixels
+ convert_options.height = 800 # Specify height in pixels
+ convert_options.brightness = 50 # Adjust brightness (0-100)
+ convert_options.contrast = 50 # Adjust contrast (0-100)
+ convert_options.gamma = 0.5 # Adjust gamma
+ convert_options.rotation_angle = 0 # No rotation
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Document converted successfully to TIFF: {len(result)} files")
+ for image in result:
+ print(f" - {image.name} ({image.size} bytes)")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based Conversion to Image Format
+
+For applications that need to process the converted images directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.docx",
+ format: "jpg",
+ loadOptions: {
+ // DOCX-specific load options if needed
+ },
+ convertOptions: {
+ // JPG-specific convert options
+ fromPage: 1,
+ pagesCount: 2,
+ quality: 90,
+ grayscale: false,
+ rotateAngle: 0
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Create a folder for storing images if it doesn't exist
+ if (!fs.existsSync("./images")) {
+ fs.mkdirSync("./images");
+ }
+
+ // Save the stream to a file
+ const fileName = "./images/converted-image.jpg";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`Document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## Image-Specific Conversion Options
+
+When converting to image formats, you can leverage these specialized options:
+
+| Option | Description | Applicable Formats | Default |
+|--------|-------------|-------------------|---------|
+| FromPage | First page number to convert | All | 1 |
+| PagesCount | Number of pages to convert | All | All pages |
+| Dpi | Resolution in dots per inch | All | 96 |
+| Width | Width of the resulting image | All | Automatic |
+| Height | Height of the resulting image | All | Automatic |
+| Quality | Image quality (1-100) | JPG | 90 |
+| Grayscale | Convert to grayscale | JPG, PNG, TIFF, BMP | false |
+| RotateAngle | Rotation angle | All | 0 |
+| UsePdf | Use PDF as intermediate format | All | false |
+| BackgroundColor | Background color | PNG, BMP | "white" |
+| Brightness | Image brightness (0-100) | TIFF | 50 |
+| Contrast | Image contrast (0-100) | TIFF | 50 |
+| Gamma | Image gamma (0.0-2.0) | TIFF | 1.0 |
+
+## Troubleshooting Common Issues
+
+### 1. Image Quality Issues
+
+If the converted images have poor quality:
+- Increase the DPI value (200-300 is recommended for good quality)
+- For JPG format, increase the quality setting (90-100 for high quality)
+- If text appears blurry, try enabling the `UsePdf` option for better text rendering
+
+### 2. Size and Resolution Problems
+
+If the images aren't the expected size:
+- Explicitly set both width and height parameters
+- If aspect ratio is important, set only one dimension (width or height) and let the API calculate the other
+- For very large documents, consider increasing DPI gradually to avoid memory issues
+
+### 3. Color and Appearance Issues
+
+If colors don't match the original document:
+- For PNG, try different background color settings
+- For JPG, adjust quality, and disable grayscale if color is needed
+- For TIFF, adjust brightness, contrast, and gamma settings
+
+### 4. Multi-page Document Handling
+
+When working with multi-page documents:
+- Use the `FromPage` and `PagesCount` parameters to control which pages are converted
+- For large documents, consider processing pages in batches to avoid timeouts
+- Remember that each page typically generates a separate image file (except for multi-page TIFF)
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to different image formats
+- Customizing image conversion options for optimal quality and appearance
+- Controlling page selection for multi-page document conversion
+- Implementing both storage-based and stream-based image conversions
+- Troubleshooting common image conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a thumbnail generator that converts each page to a small PNG image
+2. Build a document previewer that shows document pages as images in a web interface
+3. Implement a batch conversion utility that processes multiple documents to images
+4. Create a service that automatically optimizes image quality based on content type
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-to-pdf-formats/_index.md b/content/conversion/english/advanced-features/convert-to-pdf-formats/_index.md
new file mode 100644
index 0000000..2353857
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-pdf-formats/_index.md
@@ -0,0 +1,551 @@
+---
+title: Converting to PDF Formats with Advanced Options Tutorial
+description: Learn how to convert various document types to PDF with advanced options using GroupDocs.Conversion Cloud API in this comprehensive developer tutorial.
+url: /advanced-features/convert-to-pdf-formats/
+weight: 40
+---
+
+# Tutorial: Converting to PDF Formats with Advanced Options
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Convert various document formats to PDF with GroupDocs.Conversion Cloud API
+- Configure advanced PDF options like resolution, compression, and security
+- Optimize PDF output for different business needs
+- Control page layout, bookmarks, and metadata
+- Implement PDF conversion across different programming languages
+- Solve common PDF conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- Source documents for conversion (DOCX, XLSX, PPTX, images, etc.)
+
+## Why Convert to PDF Format?
+
+PDF (Portable Document Format) has become the standard for document exchange and has several advantages:
+
+- Platform independence: Looks the same on any device or operating system
+- Visual fidelity: Preserves exact layout, fonts, and formatting
+- Security: Supports encryption, permissions, and digital signatures
+- File size optimization: Can be compressed without significant quality loss
+- Archiving: Ideal for long-term document storage
+- Ease of sharing: Widely accepted format in business environments
+
+GroupDocs.Conversion Cloud API offers powerful capabilities to convert almost any document format to PDF with precise control over the output.
+
+## Implementation Steps
+
+### Step 1: Set Up Your Development Environment
+
+First, ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 2: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, you need to authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+var configuration = new Configuration(MyClientId, MyClientSecret);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 3: Basic PDF Conversion
+
+Let's start with a basic conversion to PDF:
+
+```csharp
+// Basic conversion to PDF
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ OutputPath = "converted/basic.pdf"
+}
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted successfully: " + response[0].Url);
+```
+
+### Step 4: Advanced PDF Conversion Options
+
+Now, let's explore advanced PDF options for greater control:
+
+```csharp
+// Advanced PDF conversion with options
+var pdfOptions = new PdfConvertOptions
+{
+ // Document layout options
+ Dpi = 300, // Resolution in dots per inch
+ Width = 800, // Width in pixels
+ Height = 1200, // Height in pixels
+
+ // Visual options
+ Grayscale = false, // Color or grayscale
+ Zoom = 100, // Zoom level (100 = 100%)
+
+ // Security options
+ Password = "password123", // Document password
+
+ // Optimization options
+ CompressImages = true, // Compress images to reduce size
+ ImageQuality = 95, // Image quality (0-100)
+ UnembedFonts = false, // Keep fonts embedded
+
+ // PDF-specific options
+ BookmarksOutlineLevel = 2, // Bookmarks visibility level
+ CenterWindow = true, // Center document in viewer
+ DisplayDocTitle = true, // Display document title
+ FitWindow = true, // Fit view to window
+
+ // Page options
+ FromPage = 1, // Start page
+ PagesCount = 5, // Number of pages to convert
+
+ // Cleanup options
+ RemoveUnusedObjects = true, // Remove unused objects
+ RemoveUnusedStreams = true, // Remove unused streams
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = pdfOptions,
+ OutputPath = "converted/advanced.pdf"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted with advanced options: " + response[0].Url);
+```
+
+### Step 5: Password-Protected PDF Conversion
+
+You can create password-protected PDFs for sensitive documents:
+
+```csharp
+// Create password-protected PDF
+var secureOptions = new PdfConvertOptions
+{
+ Password = "securePassword123", // Set document password
+ // Additional security options
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = secureOptions,
+ OutputPath = "converted/secure.pdf"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Secure PDF created: " + response[0].Url);
+```
+
+### Step 6: PDF/A Compliance
+
+For archival purposes, you can create PDF/A compliant files:
+
+```csharp
+// Create PDF/A compliant document
+var pdfaOptions = new PdfConvertOptions
+{
+ RemovePdfaCompliance = false, // Keep PDF/A compliance
+ // Other options...
+};
+
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = pdfaOptions,
+ OutputPath = "converted/pdfa.pdf"
+};
+
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("PDF/A document created: " + response[0].Url);
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class ConvertToPdfExample
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyClientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+ string MyClientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+
+ // Create necessary API instances
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Example 1: Basic PDF conversion
+ var basicSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ OutputPath = "converted/basic.pdf"
+ };
+
+ var basicResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(basicSettings));
+ Console.WriteLine("Basic conversion completed: " + basicResponse[0].Url);
+
+ // Example 2: High-quality PDF with bookmarks
+ var highQualityOptions = new PdfConvertOptions
+ {
+ Dpi = 300,
+ BookmarksOutlineLevel = 3,
+ CompressImages = false,
+ ImageQuality = 100,
+ DisplayDocTitle = true
+ };
+
+ var highQualitySettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = highQualityOptions,
+ OutputPath = "converted/high-quality.pdf"
+ };
+
+ var highQualityResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(highQualitySettings));
+ Console.WriteLine("High-quality conversion completed: " + highQualityResponse[0].Url);
+
+ // Example 3: Optimized PDF for web sharing
+ var optimizedOptions = new PdfConvertOptions
+ {
+ CompressImages = true,
+ ImageQuality = 75,
+ Linearize = true, // Optimized for web viewing
+ UnembedFonts = true,
+ RemoveUnusedObjects = true,
+ RemoveUnusedStreams = true
+ };
+
+ var optimizedSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = optimizedOptions,
+ OutputPath = "converted/optimized.pdf"
+ };
+
+ var optimizedResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(optimizedSettings));
+ Console.WriteLine("Optimized conversion completed: " + optimizedResponse[0].Url);
+
+ // Example 4: Secure PDF
+ var secureOptions = new PdfConvertOptions
+ {
+ Password = "securePassword123",
+ UnembedFonts = false,
+ CompressImages = true,
+ ImageQuality = 90
+ };
+
+ var secureSettings = new ConvertSettings
+ {
+ FilePath = "WordProcessing/sample.docx",
+ Format = "pdf",
+ ConvertOptions = secureOptions,
+ OutputPath = "converted/secure.pdf"
+ };
+
+ var secureResponse = apiInstance.ConvertDocument(new ConvertDocumentRequest(secureSettings));
+ Console.WriteLine("Secure PDF created: " + secureResponse[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception when calling ConvertApi: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API
+api = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Example 1: Basic PDF conversion
+ basic_settings = groupdocs_conversion_cloud.ConvertSettings()
+ basic_settings.file_path = "WordProcessing/sample.docx"
+ basic_settings.format = "pdf"
+ basic_settings.output_path = "converted/basic.pdf"
+
+ basic_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(basic_settings))
+ print(f"Basic conversion completed: {basic_result[0].url}")
+
+ # Example 2: High-quality PDF with bookmarks
+ high_quality_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ high_quality_options.dpi = 300
+ high_quality_options.bookmarks_outline_level = 3
+ high_quality_options.compress_images = False
+ high_quality_options.image_quality = 100
+ high_quality_options.display_doc_title = True
+
+ high_quality_settings = groupdocs_conversion_cloud.ConvertSettings()
+ high_quality_settings.file_path = "WordProcessing/sample.docx"
+ high_quality_settings.format = "pdf"
+ high_quality_settings.convert_options = high_quality_options
+ high_quality_settings.output_path = "converted/high-quality.pdf"
+
+ high_quality_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(high_quality_settings))
+ print(f"High-quality conversion completed: {high_quality_result[0].url}")
+
+ # Example 3: Optimized PDF for web sharing
+ optimized_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ optimized_options.compress_images = True
+ optimized_options.image_quality = 75
+ optimized_options.linearize = True # Optimized for web viewing
+ optimized_options.unembed_fonts = True
+ optimized_options.remove_unused_objects = True
+ optimized_options.remove_unused_streams = True
+
+ optimized_settings = groupdocs_conversion_cloud.ConvertSettings()
+ optimized_settings.file_path = "WordProcessing/sample.docx"
+ optimized_settings.format = "pdf"
+ optimized_settings.convert_options = optimized_options
+ optimized_settings.output_path = "converted/optimized.pdf"
+
+ optimized_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(optimized_settings))
+ print(f"Optimized conversion completed: {optimized_result[0].url}")
+
+ # Example 4: Grayscale PDF
+ grayscale_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ grayscale_options.grayscale = True
+ grayscale_options.dpi = 300
+
+ grayscale_settings = groupdocs_conversion_cloud.ConvertSettings()
+ grayscale_settings.file_path = "WordProcessing/sample.docx"
+ grayscale_settings.format = "pdf"
+ grayscale_settings.convert_options = grayscale_options
+ grayscale_settings.output_path = "converted/grayscale.pdf"
+
+ grayscale_result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(grayscale_settings))
+ print(f"Grayscale conversion completed: {grayscale_result[0].url}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now use the token to convert document with advanced PDF options
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'WordProcessing/sample.docx',
+ 'Format': 'pdf',
+ 'ConvertOptions': {
+ 'Dpi': 300,
+ 'Width': 800,
+ 'Height': 1200,
+ 'BookmarksOutlineLevel': 2,
+ 'CenterWindow': true,
+ 'CompressImages': true,
+ 'DisplayDocTitle': true,
+ 'FitWindow': true,
+ 'FromPage': 1,
+ 'PagesCount': 5,
+ 'Grayscale': false,
+ 'ImageQuality': 95,
+ 'LinearizeDocument': true,
+ 'Zoom': 100
+ },
+ 'OutputPath': 'converted/advanced.pdf'
+}"
+```
+
+## PDF Conversion Use Cases
+
+### Use Case 1: High-Quality Archival Documents
+
+For organizations that need to archive important documents with maximum fidelity and compliance:
+
+```csharp
+var archivalOptions = new PdfConvertOptions
+{
+ Dpi = 300, // High resolution
+ CompressImages = false, // No image compression
+ ImageQuality = 100, // Maximum quality
+ RemovePdfaCompliance = false, // Maintain PDF/A compliance
+ Grayscale = false, // Keep color information
+ BookmarksOutlineLevel = 3 // Include detailed bookmarks
+};
+```
+
+### Use Case 2: Web-Optimized Documents
+
+For documents that will be distributed online where file size matters:
+
+```csharp
+var webOptions = new PdfConvertOptions
+{
+ CompressImages = true, // Compress images
+ ImageQuality = 75, // Lower quality is smaller
+ Dpi = 150, // Lower resolution is smaller
+ UnembedFonts = true, // Remove embedded fonts
+ RemoveUnusedObjects = true, // Clean up unused objects
+ RemoveUnusedStreams = true, // Clean up unused streams
+ Linearize = true // Optimize for web viewing
+};
+```
+
+### Use Case 3: Secure Confidential Documents
+
+For sensitive documents that need protection:
+
+```csharp
+var secureOptions = new PdfConvertOptions
+{
+ Password = "StrongPassword123!", // Document password
+ UnembedFonts = false, // Keep fonts embedded for fidelity
+ Grayscale = false, // Keep color information
+ ImageQuality = 90 // Good quality without excessive size
+};
+```
+
+## Advanced PDF Features Explanation
+
+### Bookmarks and Navigation
+
+The `BookmarksOutlineLevel` option controls how document headings are converted to PDF bookmarks:
+
+- Value 0: No bookmarks are created
+- Value 1: Only the highest level headings become bookmarks
+- Value 2+: More detailed heading levels are included as nested bookmarks
+
+### PDF Optimization
+
+These options help reduce file size:
+
+- CompressImages: Enables image compression
+- ImageQuality: Sets compression quality (lower values = smaller files)
+- UnembedFonts: Removes embedded fonts to reduce size
+- RemoveUnusedObjects/Streams: Cleans up unnecessary data
+
+### PDF/A Compliance
+
+PDF/A is an ISO-standardized version for long-term archiving:
+
+- RemovePdfaCompliance: When set to `false`, maintains PDF/A compatibility
+
+## Troubleshooting Tips
+
+### Large File Sizes
+Issue: The converted PDF is too large.Solution:
+- Enable `CompressImages` and reduce `ImageQuality`
+- Set `UnembedFonts` to true if font fidelity is not critical
+- Enable `RemoveUnusedObjects` and `RemoveUnusedStreams`
+- Consider reducing the `Dpi` value
+
+### Missing Bookmarks
+Issue: PDF doesn't contain the expected bookmarks.Solution:
+- Ensure the source document has proper heading styles
+- Increase the `BookmarksOutlineLevel` value
+- Check if the source document format supports heading extraction
+
+### Font Issues
+Issue: Text appears with incorrect fonts in the PDF.Solution:
+- Set `UnembedFonts` to false
+- Provide custom fonts via the `FontsPath` property
+- Use standard fonts like Arial or Times New Roman in the source document
+
+## Try It Yourself
+
+Now that you've learned about PDF conversion options, try these exercises:
+
+1. Convert a document to a small, web-optimized PDF
+2. Create a high-quality PDF with full bookmarks for archiving
+3. Convert a document to grayscale PDF for printing
+4. Create a password-protected PDF with custom security settings
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Convert various document formats to PDF using GroupDocs.Conversion Cloud API
+- Configure advanced PDF options for different business requirements
+- Optimize PDF output for web, print, or archiving purposes
+- Control security features like password protection
+- Manage document appearance including resolution and color mode
+- Troubleshoot common PDF conversion issues
+
+## Next Steps
+
+Now that you know how to create customized PDFs, you might want to explore:
+- [Tutorial: How to Add Watermarks During Conversion](/advanced-features/add-watermark/)
+- [Tutorial: How to Convert Specific Pages](/advanced-features/convert-specific-pages/)
+- [Tutorial: Converting to Image Formats](/advanced-features/convert-to-image-formats/)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).;
+
diff --git a/content/conversion/english/advanced-features/convert-to-pdf/_index.md b/content/conversion/english/advanced-features/convert-to-pdf/_index.md
new file mode 100644
index 0000000..fc295cc
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-pdf/_index.md
@@ -0,0 +1,449 @@
+---
+title: How to Convert Documents to PDF Formats with GroupDocs.Conversion Cloud API
+description: Learn to convert various document types to PDF and PDF/A formats with security, optimization and formatting options using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-pdf/
+weight: 200
+---
+
+# Tutorial: Converting Documents to PDF Formats
+
+In this tutorial, you'll learn how to convert various document types to PDF and PDF/A formats using GroupDocs.Conversion Cloud API. You'll master PDF conversion with advanced options including security settings, compression, and PDF/A compliance for archival purposes.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to standard PDF and PDF/A formats
+- Apply security settings including passwords and permissions
+- Optimize PDF output with compression and metadata options
+- Control PDF appearance with bookmarks and display settings
+- Implement both storage-based and stream-based PDF conversions
+- Troubleshoot common PDF conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including Word, Excel, and images)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+The response will contain a JWT token that needs to be used in subsequent requests.
+
+### Step 2: Basic Document to PDF Conversion
+
+Let's start with a simple conversion from a Word document to PDF format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting to PDF with Advanced Options
+
+Now let's implement a comprehensive example that converts a document to PDF with specific PDF conversion options:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace PdfConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up advanced conversion to PDF with options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "pdf",
+ // For password-protected documents
+ LoadOptions = new DocxLoadOptions()
+ {
+ Password = "",
+ HideWordTrackedChanges = true,
+ DefaultFont = "Arial"
+ },
+ // PDF-specific convert options
+ ConvertOptions = new PdfConvertOptions()
+ {
+ // Page options
+ FromPage = 1,
+ PagesCount = 5,
+
+ // Security options
+ Password = "securePassword", // Set PDF password
+ PermissionsPassword = "ownerPwd", // Set permissions password
+ Permissions = new List // Restrict PDF permissions
+ {
+ "PrintDocument",
+ "ModifyContent"
+ },
+
+ // Appearance options
+ Zoom = 100,
+ Dpi = 300,
+ MarginTop = 10,
+ MarginBottom = 10,
+ MarginLeft = 10,
+ MarginRight = 10,
+
+ // PDF features
+ BookmarksOutlineLevel = 2, // Include 2 levels of bookmarks
+ CenterWindow = true, // Center window when opened
+ DisplayDocTitle = true, // Display document title
+ FitWindow = true, // Fit window to document
+
+ // Optimization options
+ Grayscale = false, // Keep colors
+ RemoveUnusedStreams = true, // Remove unused content
+ RemoveUnusedObjects = true, // Remove unused objects
+ CompressImages = true, // Compress images
+ ImageQuality = 95, // Image quality (1-100)
+ UnembedFonts = false // Keep embedded fonts
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully to PDF: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting to PDF/A for Archiving
+
+PDF/A is a specialized format for long-term archiving. Let's convert a document to PDF/A format:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class PdfAConversionExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for PDF/A
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/sample.docx");
+ settings.setFormat("pdfa_2a"); // Use PDF/A-2a format
+
+ // Set Word-specific load options if needed
+ WordProcessingLoadOptions loadOptions = new WordProcessingLoadOptions();
+ loadOptions.setDefaultFont("Times New Roman");
+ settings.setLoadOptions(loadOptions);
+
+ // Configure PDF/A-specific convert options
+ PdfConvertOptions convertOptions = new PdfConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(0); // Convert all pages
+ convertOptions.setDpi(300); // High resolution
+ convertOptions.setWidth(595); // Standard A4 width in points
+ convertOptions.setHeight(842); // Standard A4 height in points
+
+ // Set PDF/A compliance options
+ convertOptions.setRemovePdfaCompliance(false); // Maintain PDF/A compliance
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Document converted successfully to PDF/A: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Creating Secure PDF Documents
+
+Security is often a concern with PDF documents. Here's how to create PDFs with various protection settings:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/confidential.docx"
+ settings.format = "pdf"
+
+ # Configure PDF-specific convert options with security settings
+ convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+
+ # Document open password - user needs this to open document
+ convert_options.password = "userPassword123"
+
+ # Owner password for changing permissions
+ convert_options.permissions_password = "ownerPassword456"
+
+ # Set specific permissions
+ convert_options.permissions = [
+ "PrintDocument", # Allow printing
+ "ModifyAnnotations", # Allow annotation editing
+ "AssembleDocument" # Allow document assembly
+ ]
+
+ # Block these permissions (not explicitly allowed above)
+ # - Content copying
+ # - Content extraction
+ # - Content editing
+ # - Printing in high quality
+
+ # Optimization and appearance
+ convert_options.dpi = 300
+ convert_options.center_window = True
+ convert_options.fit_window = True
+ convert_options.display_doc_title = True
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted/secure"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Secure PDF created successfully: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based PDF Conversion
+
+For applications that need to process the converted PDF directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.docx",
+ format: "pdf",
+ loadOptions: {
+ // DOCX-specific load options if needed
+ },
+ convertOptions: {
+ // PDF-specific convert options
+ fromPage: 1,
+ pagesCount: 0, // All pages
+ dpi: 300,
+ linearize: true, // Optimize for web viewing (Fast Web View)
+ removeUnusedObjects: true,
+ removeUnusedStreams: true,
+ compressImages: true,
+ imageQuality: 95
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-document.pdf";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`Document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## PDF-Specific Conversion Options
+
+When converting to PDF formats, you can leverage these specialized options:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| Password | Document open password | null |
+| PermissionsPassword | Password for changing permissions | null |
+| Permissions | List of allowed permissions | All |
+| PdfFormat | Target PDF format version | "PDF" |
+| FromPage | First page number to convert | 1 |
+| PagesCount | Number of pages to convert | All pages |
+| Dpi | Resolution in dots per inch | 96 |
+| Width | Width of the resulting document | Auto |
+| Height | Height of the resulting document | Auto |
+| BookmarksOutlineLevel | Bookmark outline level to include | 0 (none) |
+| CenterWindow | Center window when opened | false |
+| CompressImages | Compress images in the PDF | false |
+| DisplayDocTitle | Display document title instead of filename | false |
+| FitWindow | Fit window to first page | false |
+| Grayscale | Convert to grayscale | false |
+| RemoveUnusedObjects | Remove unused objects | false |
+| RemoveUnusedStreams | Remove unused streams | false |
+| UnembedFonts | Remove embedded fonts | false |
+| Linearize | Optimize for web viewing | false |
+| ImageQuality | Image quality (1-100) | 100 |
+| RemovePdfaCompliance | Remove PDF/A compliance | true |
+
+### Available PDF Permissions
+
+When setting the `Permissions` property, you can include any of these values:
+
+- PrintDocument
+- ModifyContent
+- CopyContent
+- ModifyAnnotations
+- FillForm
+- ExtractContent
+- AssembleDocument
+- HighQualityPrint
+
+## Troubleshooting Common Issues
+
+### 1. PDF Security Issues
+
+If you encounter problems with PDF security:
+- Verify that both password and permissions password are set correctly
+- Ensure permissions are properly specified as a list of allowed actions
+- Remember that some readers may not support all security features
+
+### 2. PDF/A Compliance Problems
+
+If your PDF/A conversion is rejected by validation tools:
+- Set `RemovePdfaCompliance` to false
+- Ensure all fonts used in the document can be embedded
+- Avoid transparent images or elements
+- Consider using PDF/A-2 or PDF/A-3 for more complex documents
+
+### 3. Size and Quality Optimization
+
+If the PDF file size is too large:
+- Enable `CompressImages` and reduce `ImageQuality` (75-85 offers good balance)
+- Set `RemoveUnusedObjects` and `RemoveUnusedStreams` to true
+- Consider using `Grayscale` for documents that don't require color
+- Set appropriate DPI (150-300 is sufficient for most purposes)
+
+### 4. Font and Layout Issues
+
+If fonts or layout appear incorrect:
+- Specify the `DefaultFont` in load options
+- Increase DPI for better text rendering
+- If possible, ensure fonts are available in the conversion environment
+- For complex layouts, adjust margins or use `FitWindow` option
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to PDF and PDF/A
+- Implementing PDF security with passwords and permissions
+- Optimizing PDF output with compression and metadata options
+- Controlling PDF appearance with bookmarks and display settings
+- Creating both storage-based and stream-based PDF conversions
+- Troubleshooting common PDF conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a secure PDF converter that applies different security levels based on content type
+2. Implement a batch conversion utility that optimizes multiple documents to PDF with size reduction
+3. Build a PDF/A converter specifically for archiving important documents
+4. Create a service that adds bookmarks to PDFs based on document headings
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting to HTML Format](/advanced-features/convert-to-html) to master conversion to web-friendly formats with customization options.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-to-spreadsheet/_index.md b/content/conversion/english/advanced-features/convert-to-spreadsheet/_index.md
new file mode 100644
index 0000000..e39ec65
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-spreadsheet/_index.md
@@ -0,0 +1,359 @@
+---
+title: Converting Documents to Spreadsheet Formats with GroupDocs.Conversion Cloud API Tutorial
+description: Learn how to convert various document types to Excel and other spreadsheet formats using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-spreadsheet/
+weight: 50
+---
+
+# Tutorial: Converting Documents to Spreadsheet Formats
+
+In this tutorial, you'll learn how to convert various document types to Excel and other spreadsheet formats using GroupDocs.Conversion Cloud API. We'll cover conversion with different output options, handling complex conversions, and both storage-based and stream-based conversion methods.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to XLSX, XLS, and other spreadsheet formats
+- Customize spreadsheet conversion options for optimal results
+- Process password-protected documents during conversion
+- Implement both storage-based and stream-based conversions
+- Handle common spreadsheet conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including Word and PDF)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+If using an SDK, authentication is handled when configuring the client:
+
+```java
+// Java SDK example
+String clientId = "YOUR_CLIENT_ID";
+String clientSecret = "YOUR_CLIENT_SECRET";
+Configuration configuration = new Configuration(clientId, clientSecret);
+ConvertApi apiInstance = new ConvertApi(configuration);
+```
+
+### Step 2: Basic Document to Spreadsheet Conversion
+
+Let's start with a basic conversion from a Word document to XLSX format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'xlsx',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Don't forget to replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+The response will contain the URL to the converted file:
+
+```json
+{
+ "name": "sample.xlsx",
+ "size": 7265,
+ "url": "MyStorage:converted/sample.xlsx"
+}
+```
+
+### Step 3: Implementing Conversion with Specific Options
+
+Now, let's implement a complete example that converts a document to XLSX with specific spreadsheet conversion options:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class ConvertToSpreadsheetExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings with spreadsheet-specific options
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/sample.docx");
+ settings.setFormat("xlsx");
+
+ // Specify spreadsheet conversion options
+ SpreadsheetConvertOptions convertOptions = new SpreadsheetConvertOptions();
+ convertOptions.setFromPage(1); // Start from first page
+ convertOptions.setPagesCount(5); // Convert up to 5 pages
+ convertOptions.setZoom(150); // Set zoom level to 150%
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Document converted successfully: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 4: Converting from PDF to XLSX
+
+PDF documents often contain tabular data that would be valuable in spreadsheet form. Here's how to convert a PDF to XLSX:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/sample.pdf"
+ settings.format = "xlsx"
+
+ # Configure PDF-specific load options
+ load_options = groupdocs_conversion_cloud.PdfLoadOptions()
+ load_options.password = "" # If PDF is protected, provide password
+ load_options.hide_pdf_annotations = True
+ load_options.flatten_all_fields = True
+
+ settings.load_options = load_options
+
+ # Configure Excel-specific convert options
+ convert_options = groupdocs_conversion_cloud.SpreadsheetConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 10
+ convert_options.password = "newPassword" # Optional: Password-protect the result
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Document converted successfully: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 5: Stream-Based Conversion to Spreadsheet
+
+For applications that need to process the converted spreadsheet directly without storing it:
+
+```csharp
+// C# SDK Example
+using System;
+using System.IO;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace ConversionToSpreadsheetTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Specify conversion settings - note OutputPath is null for stream output
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "xlsx",
+ ConvertOptions = new XlsxConvertOptions()
+ {
+ FromPage = 1,
+ PagesCount = 5
+ },
+ // OutputPath = null indicates stream output
+ OutputPath = null
+ };
+
+ // Convert and get result as a stream
+ Stream response = apiInstance.ConvertDocumentDownload(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully, stream size: " +
+ response.Length.ToString() + " bytes");
+
+ // Process the stream as needed, for example, save to local file
+ using (var fileStream = File.Create("converted-spreadsheet.xlsx"))
+ {
+ response.CopyTo(fileStream);
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 6: Converting Password-Protected Documents
+
+If you need to convert password-protected documents to spreadsheet formats:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/protected.docx",
+ format: "xlsx",
+ loadOptions: {
+ // DocxLoadOptions for password-protected Word document
+ password: "documentPassword",
+ hideWordTrackedChanges: true,
+ defaultFont: "Arial"
+ },
+ convertOptions: {
+ // XlsxConvertOptions for resulting spreadsheet
+ fromPage: 1,
+ pagesCount: 10,
+ password: "resultPassword", // Optional: set password for the resulting file
+ usePdf: false
+ },
+ outputPath: "converted"
+};
+
+// Execute conversion
+apiInstance.convertDocument({ convertSettings: settings })
+ .then((result) => {
+ console.log(`Document converted successfully: ${result[0].url}`);
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## Spreadsheet-Specific Conversion Options
+
+When converting to spreadsheet formats, you can take advantage of these specialized options:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| FromPage | First page number to convert | 1 |
+| PagesCount | Number of pages to convert | All pages |
+| Password | Set password for the resulting spreadsheet | null |
+| Zoom | Zoom factor for conversion (in %) | 100 |
+| UsePdf | Whether to use PDF as intermediate format | false |
+| OnePagePerSheet | Place each page on a separate worksheet | false |
+| ShowGridLines | Display grid lines in the resulting spreadsheet | true |
+| SetCustomHeight | Use custom row height | false |
+
+## Troubleshooting Common Issues
+
+### 1. Table Structure Issues
+
+If the table structure in the converted spreadsheet doesn't match the original:
+- Try setting `UsePdf` to true, which may preserve layout better
+- For complex tables, consider using the intermediate PDF conversion
+
+### 2. Formatting Problems
+
+If formatting isn't preserved properly:
+- Check if the source document uses custom fonts and consider specifying them
+- Try adjusting the zoom level to improve layout preservation
+
+### 3. Performance Considerations
+
+For large documents:
+- Use the `FromPage` and `PagesCount` parameters to convert only the needed pages
+- Consider using parallel processing for batch conversions
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to spreadsheet formats
+- Customizing spreadsheet conversion options for optimal results
+- Handling password protection during conversion
+- Implementing both storage-based and stream-based approaches
+- Troubleshooting common spreadsheet conversion issues
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Convert a multi-page PDF document to XLSX with each page as a separate worksheet
+2. Create a batch conversion utility that converts multiple documents to spreadsheet format
+3. Implement a web form that allows users to upload and convert documents with custom options
+4. Add error handling that provides useful feedback for common conversion issues
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting Documents to Word Processing Formats](/advanced-features/convert-to-word-processing) to master specialized conversions to DOCX, DOC, and other text document formats.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
\ No newline at end of file
diff --git a/content/conversion/english/advanced-features/convert-to-text/_index.md b/content/conversion/english/advanced-features/convert-to-text/_index.md
new file mode 100644
index 0000000..735c6ab
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-text/_index.md
@@ -0,0 +1,379 @@
+---
+title: Learn to Convert to Text Format with GroupDocs.Conversion Cloud API
+description: Learn to extract and convert documents to plain text format with customization options using GroupDocs.Conversion Cloud API
+url: /advanced-features/convert-to-text/
+weight: 100
+---
+
+# Tutorial: Converting to Text Format
+
+In this tutorial, you'll learn how to convert various document types to plain text format using GroupDocs.Conversion Cloud API. You'll master text extraction with options for controlling output formatting, encoding, and content selection.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to plain text format (.txt)
+- Control text encoding and formatting during conversion
+- Extract text from specific pages or sections of documents
+- Implement both storage-based and stream-based text conversions
+- Handle common text extraction challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including PDF, Word, and emails)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic Document to Text Conversion
+
+Let's start with a simple conversion from a Word document to plain text format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.docx',
+ 'Format': 'txt',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting to Text with Encoding Options
+
+Character encoding is crucial when working with text files. Here's how to specify encoding:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace TextConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion to text with encoding options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.docx",
+ Format = "txt",
+ // For password-protected documents
+ LoadOptions = new DocxLoadOptions()
+ {
+ Password = ""
+ },
+ // Text-specific convert options
+ ConvertOptions = new TxtConvertOptions()
+ {
+ // Page selection
+ FromPage = 1,
+ PagesCount = 0, // All pages
+
+ // Encoding options (UTF-8)
+ Encoding = "utf-8"
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully to text: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting PDF to Text with Advanced Options
+
+PDF documents often require special handling for effective text extraction:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class PdfToTextExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/document.pdf");
+ settings.setFormat("txt");
+
+ // Set PDF-specific load options
+ PdfLoadOptions loadOptions = new PdfLoadOptions();
+ loadOptions.setPassword(""); // If PDF is protected
+ loadOptions.setRemoveEmbeddedFiles(true); // Ignore embedded files
+ loadOptions.setHidePdfAnnotations(true); // Ignore annotations
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure TXT-specific convert options
+ TxtConvertOptions convertOptions = new TxtConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(0); // All pages
+
+ // Set UTF-8 encoding for universal compatibility
+ convertOptions.setEncoding("utf-8");
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("PDF converted successfully to text: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting Email Messages to Text
+
+Email messages often contain rich formatting that needs to be properly extracted:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/email_message.msg"
+ settings.format = "txt"
+
+ # Configure email-specific load options
+ load_options = groupdocs_conversion_cloud.EmailLoadOptions()
+ load_options.display_header = True # Include email header
+ load_options.display_from_email_address = True
+ load_options.display_to_email_address = True
+ load_options.display_cc_email_address = True
+ load_options.display_bcc_email_address = False
+ load_options.preserve_embedded_message_format = True
+
+ settings.load_options = load_options
+
+ # Configure text-specific convert options
+ convert_options = groupdocs_conversion_cloud.TxtConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 0 # All content
+ convert_options.encoding = "utf-8"
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Email converted successfully to text: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based Text Conversion
+
+For applications that need to process the extracted text directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.docx",
+ format: "txt",
+ loadOptions: {
+ // DOCX-specific load options if needed
+ },
+ convertOptions: {
+ // TXT-specific convert options
+ fromPage: 1,
+ pagesCount: 0, // All pages
+ encoding: "utf-8"
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Process the text directly
+ let textContent = '';
+ result.on('data', (chunk) => {
+ textContent += chunk.toString('utf8');
+ });
+
+ result.on('end', () => {
+ console.log("Document converted successfully to text");
+
+ // Display first 100 characters of the extracted text
+ const previewText = textContent.substring(0, 100) +
+ (textContent.length > 100 ? '...' : '');
+ console.log("Text preview: " + previewText);
+
+ // Save to file if needed
+ fs.writeFile("extracted-text.txt", textContent, (err) => {
+ if (err) {
+ console.error("Error saving text file:", err);
+ } else {
+ console.log("Text saved to extracted-text.txt");
+ }
+ });
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## Text-Specific Conversion Options
+
+When converting to text format, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| FromPage | First page number to convert | 1 | Controls starting point |
+| PagesCount | Number of pages to convert | All | Limits content amount |
+| Encoding | Character encoding for the text file | "utf-8" | Affects character support and compatibility |
+
+## Troubleshooting Common Issues
+
+### 1. Character Encoding Problems
+
+If text appears garbled or contains unexpected characters:
+- Ensure you're using the correct encoding for your content (UTF-8 is recommended for most cases)
+- For documents with special characters, consider using UTF-16 encoding
+- For legacy systems, you might need to use specific encodings like Windows-1252 or ISO-8859-1
+
+### 2. Content Formatting Loss
+
+Text conversion naturally loses formatting:
+- Remember that TXT format doesn't support formatting like bold, italics, or colors
+- For tabular data, tables will be converted to plain text with spacing that might not align perfectly
+- Consider HTML or PDF format if formatting preservation is critical
+
+### 3. Special Content Handling
+
+Some document elements require special handling:
+- Headers and footers may be included in unexpected locations
+- Page numbers might be interspersed with regular content
+- For complex documents with tables, charts, or images, the text representation might be confusing
+
+### 4. Performance Considerations
+
+For large documents:
+- Use the page selection options to convert only needed sections
+- Consider batching very large documents into smaller chunks
+- Monitor memory usage when processing large streams
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to plain text
+- Controlling text encoding for proper character representation
+- Extracting text from specific pages or sections
+- Implementing both storage-based and stream-based text conversions
+- Troubleshooting common text conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a text extractor that processes multiple document types and normalizes the output format
+2. Implement a command-line utility that extracts text and performs basic processing (e.g., word count, search)
+3. Build a simple indexing service that extracts text for search functionality
+4. Create a comparison tool that shows differences between text extracted from different document versions
+
+## Next Tutorial
+
+Ready to explore more specialized conversion options? Continue with our [Tutorial: Converting CAD Documents with Load Options](/advanced-features/cad-conversion-options) to learn techniques for handling specialized CAD file formats.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-to-word-processing/_index.md b/content/conversion/english/advanced-features/convert-to-word-processing/_index.md
new file mode 100644
index 0000000..27b349a
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-to-word-processing/_index.md
@@ -0,0 +1,365 @@
+---
+title: How to Convert Documents to Word Processing Formats with GroupDocs.Conversion Cloud API
+description: Learn to convert various document types to Word formats (DOCX, DOC, RTF) using GroupDocs.Conversion Cloud API with this detailed tutorial
+url: /advanced-features/convert-to-word-processing/
+weight: 60
+---
+
+# Tutorial: Converting Documents to Word Processing Formats
+
+In this tutorial, you'll learn how to convert various document types to Word and other text document formats using GroupDocs.Conversion Cloud API. You'll master conversions to DOCX, DOC, RTF, and other formats with advanced customization options.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert documents to DOCX, DOC, RTF, and other word processing formats
+- Customize word processing conversion options for optimal results
+- Handle PDF conversions to Word with formatting preservation
+- Process conversions with both storage-based and stream-based approaches
+- Implement error handling for common Word conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample documents to test conversion (we'll use various formats including PDF and spreadsheets)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+The response will contain a JWT token that needs to be used in subsequent requests:
+
+```json
+{
+ "access_token": "YOUR_JWT_TOKEN",
+ "expires_in": 3600,
+ "token_type": "Bearer"
+}
+```
+
+### Step 2: Basic PDF to Word Conversion
+
+Let's start with one of the most common scenarios - converting a PDF document to DOCX format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.pdf',
+ 'Format': 'docx',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Don't forget to replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting PDF to Word with Advanced Options
+
+Now let's implement a complete example that converts a PDF to DOCX with specific word processing conversion options:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace WordProcessingConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from PDF to DOCX with options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/sample.pdf",
+ Format = "docx",
+ // PDF-specific load options
+ LoadOptions = new PdfLoadOptions()
+ {
+ Password = "", // If PDF is protected
+ HidePdfAnnotations = true,
+ RemoveEmbeddedFiles = false,
+ FlattenAllFields = true
+ },
+ // DOCX-specific convert options
+ ConvertOptions = new DocxConvertOptions()
+ {
+ FromPage = 1,
+ PagesCount = 5,
+ Zoom = 100,
+ Dpi = 300
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Document converted successfully: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting Excel to Word
+
+Spreadsheets often contain valuable data that needs to be included in reports and other documents. Here's how to convert Excel to Word:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class ExcelToWordExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings with spreadsheet-specific load options
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/spreadsheet.xlsx");
+ settings.setFormat("docx");
+
+ // Set Excel-specific load options
+ SpreadsheetLoadOptions loadOptions = new SpreadsheetLoadOptions();
+ loadOptions.setOnePagePerSheet(true);
+ loadOptions.setShowGridLines(true);
+ loadOptions.setShowHiddenSheets(false);
+
+ settings.setLoadOptions(loadOptions);
+
+ // Set DOCX-specific convert options
+ DocxConvertOptions convertOptions = new DocxConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(10);
+ convertOptions.setZoom(100);
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Document converted successfully: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Stream-Based Conversion to Word
+
+For applications that need to process the converted document directly without storing it:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/sample.pdf"
+ settings.format = "docx"
+
+ # Configure PDF-specific load options
+ load_options = groupdocs_conversion_cloud.PdfLoadOptions()
+ load_options.password = "" # If PDF is protected
+ load_options.hide_pdf_annotations = True
+
+ settings.load_options = load_options
+
+ # Configure Word-specific convert options
+ convert_options = groupdocs_conversion_cloud.WordProcessingConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 5
+ convert_options.dpi = 300
+
+ settings.convert_options = convert_options
+
+ # Set output_path to None for stream output
+ settings.output_path = None
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document_download(request)
+
+ # Save the stream to a file
+ with open("converted-document.docx", "wb") as f:
+ for chunk in result:
+ f.write(chunk)
+
+ print("Document converted and saved successfully")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Converting to RTF Format
+
+RTF (Rich Text Format) is a widely supported format that maintains compatibility with many word processors. Here's how to convert to RTF:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.pdf",
+ format: "rtf",
+ loadOptions: {
+ // PDF-specific load options
+ hideComments: true
+ },
+ convertOptions: {
+ // RTF-specific convert options
+ fromPage: 1,
+ pagesCount: 10,
+ dpi: 300
+ },
+ outputPath: "converted"
+};
+
+// Execute conversion
+apiInstance.convertDocument({ convertSettings: settings })
+ .then((result) => {
+ console.log(`Document converted successfully: ${result[0].url}`);
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## Word Processing Specific Conversion Options
+
+When converting to word processing formats, you can take advantage of these specialized options:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| FromPage | First page number to convert | 1 |
+| PagesCount | Number of pages to convert | All pages |
+| Dpi | Resolution in dots per inch | 96 |
+| Password | Set password for the resulting document | null |
+| Zoom | Zoom factor for conversion (in %) | 100 |
+| WidthInPixels | Width of the resulting document in pixels | Automatic |
+| HeightInPixels | Height of the resulting document in pixels | Automatic |
+
+## Troubleshooting Common Issues
+
+### 1. Formatting Issues
+
+If the formatting in the converted Word document doesn't match the original:
+- Try adjusting the DPI setting to improve image and text quality
+- For PDF sources, ensure the `FlattenAllFields` option is set appropriately
+- Consider adjusting the zoom level to preserve layout
+
+### 2. Font Problems
+
+If fonts aren't displaying correctly:
+- Ensure the font is available in the conversion environment
+- For documents with custom fonts, consider using font substitution
+- For PDF sources, try setting `EmbedFullFonts` to true
+
+### 3. Complex Layout Issues
+
+For documents with complex layouts:
+- Adjust the DPI to a higher value (300 or 600) for better quality
+- If tables appear broken, try using an intermediate format conversion
+- For PDFs with complex structure, try a two-step conversion through an intermediate format
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert various document formats to Word processing formats
+- Customizing Word conversion options for optimal results
+- Handling PDF to Word conversion with formatting preservation
+- Implementing both storage-based and stream-based approaches
+- Troubleshooting common Word conversion issues
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a web application that allows users to convert various formats to DOCX
+2. Implement a batch conversion utility that processes multiple files to RTF
+3. Build a comparison tool that shows the original document alongside the converted Word document
+4. Add format detection to automatically choose the best conversion options based on input
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting to Image Formats](/advanced-features/convert-to-images) to master document conversion to various image formats with customization options.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/convert-using-custom-font/_index.md b/content/conversion/english/advanced-features/convert-using-custom-font/_index.md
new file mode 100644
index 0000000..ecba22d
--- /dev/null
+++ b/content/conversion/english/advanced-features/convert-using-custom-font/_index.md
@@ -0,0 +1,391 @@
+---
+title: How to Use Custom Fonts in Document Conversion Tutorial
+description: Learn to implement custom fonts during document conversion to maintain precise visual fidelity using GroupDocs.Conversion Cloud API in this developer tutorial.
+url: /advanced-features/convert-using-custom-font/
+weight: 30
+---
+
+# Tutorial: How to Use Custom Fonts in Document Conversion
+
+## Learning Objectives
+
+In this tutorial, you'll learn how to:
+- Upload and use custom fonts during document conversion
+- Maintain visual fidelity of documents with unique typography
+- Configure font paths for accurate rendering
+- Solve common font-related issues in document conversion
+- Implement font substitution when necessary
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (if you don't have one, [register for a free trial](https://dashboard.groupdocs.cloud/#/apps))
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with your preferred programming language (C#, Java, Python, PHP, Ruby, or Node.js)
+- A document that uses custom fonts
+- The font files you want to use (.ttf, .otf, etc.)
+
+## Why Custom Fonts Matter in Document Conversion
+
+When converting documents that use non-standard fonts, maintaining visual fidelity can be challenging. Problems that can occur include:
+
+- Text misalignment: When a font is substituted, text spacing and layout can change
+- Character issues: Special characters may appear incorrectly or be replaced with placeholder symbols
+- Aesthetic degradation: The overall look and feel of the document changes, affecting its visual impact
+- Brand inconsistency: Corporate documents with custom brand fonts lose their identity
+
+By using GroupDocs.Conversion Cloud API's custom font capabilities, you can ensure your converted documents maintain their original appearance regardless of the target format.
+
+## Implementation Steps
+
+### Step 1: Upload Your Custom Fonts to Cloud Storage
+
+Before conversion, you need to upload your custom fonts to your cloud storage. You can use the Storage API for this:
+
+```csharp
+// This is a code example showing how to upload font files
+// In a real implementation, you'd use the Storage API to upload your font files
+```
+
+For this tutorial, we'll assume you've already uploaded your font files to a folder named "font/ttf" in your cloud storage.
+
+### Step 2: Set Up Your Development Environment
+
+Ensure you have the GroupDocs.Conversion Cloud SDK installed for your language:
+For .NET:
+```bash
+Install-Package GroupDocs.Conversion-Cloud
+```
+For Java:
+```bash
+
+ com.groupdocs
+ groupdocs-conversion-cloud
+ latest-version
+
+```
+For Python:
+```bash
+pip install groupdocs-conversion-cloud
+```
+
+### Step 3: Authenticate with the API
+
+To use GroupDocs.Conversion Cloud API, authenticate using your Client ID and Client Secret:
+
+```csharp
+// Initialize the API with your credentials
+string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+var configuration = new Configuration(MyAppSid, MyAppKey);
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 4: Configure Conversion with Custom Fonts
+
+Now, let's set up the conversion settings to use your custom fonts:
+
+```csharp
+// Prepare convert settings with custom font path
+var settings = new ConvertSettings
+{
+ FilePath = "Presentation/uses-custom-font.pptx",
+ Format = "pdf",
+ FontsPath = "font/ttf", // Path to the directory containing your fonts
+ OutputPath = "converted/with-custom-fonts.pdf"
+};
+```
+
+The `FontsPath` property is crucial - it tells the API where to look for font files during conversion.
+
+### Step 5: Execute the Conversion Request
+
+Now, let's execute the conversion with custom font settings:
+
+```csharp
+// Convert document using custom fonts
+var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+Console.WriteLine("Document converted successfully: " + response[0].Url);
+```
+
+## Complete Code Examples
+
+### Using C#
+
+```csharp
+using System;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace GroupDocs.Conversion.Cloud.Examples
+{
+ class UseCustomFontsExample
+ {
+ public static void Run()
+ {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ string MyAppKey = "XXXX-XXXX-XXXX-XXXX"; // Your AppKey
+ string MyAppSid = "XXXX-XXXX-XXXX-XXXX"; // Your AppSID
+
+ var configuration = new Configuration(MyAppSid, MyAppKey);
+
+ // Create necessary API instances
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Prepare convert settings with custom font path
+ var settings = new ConvertSettings
+ {
+ FilePath = "Presentation/uses-custom-font.pptx",
+ Format = "pdf",
+ FontsPath = "font/ttf", // Path to the directory containing your fonts
+ OutputPath = "converted/with-custom-fonts.pdf"
+ };
+
+ // Convert document using custom fonts
+ var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
+ Console.WriteLine("Document converted successfully: " + response[0].Url);
+
+ // Example 2: Convert Word document with custom fonts
+ var settings2 = new ConvertSettings
+ {
+ FilePath = "WordProcessing/custom-typography.docx",
+ Format = "pdf",
+ FontsPath = "font/ttf", // Path to the directory containing your fonts
+ OutputPath = "converted/word-with-custom-fonts.pdf"
+ };
+
+ var response2 = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings2));
+ Console.WriteLine("Word document converted successfully: " + response2[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Exception when calling ConvertApi: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Using Python
+
+```python
+# Import required modules
+import groupdocs_conversion_cloud
+import os
+
+# Get your credentials from https://dashboard.groupdocs.cloud/applications
+client_id = "XXXX-XXXX-XXXX-XXXX" # Your Client ID
+client_secret = "XXXXXXXXXXXXXXXX" # Your Client Secret
+
+# Create instance of the API
+api = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Example 1: Convert presentation with custom fonts
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "Presentation/uses-custom-font.pptx"
+ settings.format = "pdf"
+ settings.fonts_path = "font/ttf" # Path to the directory containing your fonts
+ settings.output_path = "converted/with-custom-fonts.pdf"
+
+ # Execute conversion
+ result = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings))
+ print(f"Document converted successfully: {result[0].url}")
+
+ # Example 2: Convert Word document with custom fonts
+ settings2 = groupdocs_conversion_cloud.ConvertSettings()
+ settings2.file_path = "WordProcessing/custom-typography.docx"
+ settings2.format = "pdf"
+ settings2.fonts_path = "font/ttf" # Path to the directory containing your fonts
+ settings2.output_path = "converted/word-with-custom-fonts.pdf"
+
+ # Execute conversion
+ result2 = api.convert_document(groupdocs_conversion_cloud.ConvertDocumentRequest(settings2))
+ print(f"Word document converted successfully: {result2[0].url}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Using Java
+
+```java
+// Import required packages
+import com.groupdocs.cloud.conversion.api.ConvertApi;
+import com.groupdocs.cloud.conversion.api.Configuration;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class UseCustomFontsExample {
+ public static void main(String[] args) {
+ // Get your credentials from https://dashboard.groupdocs.cloud/applications
+ String clientId = "XXXX-XXXX-XXXX-XXXX"; // Your Client ID
+ String clientSecret = "XXXXXXXXXXXXXXXX"; // Your Client Secret
+
+ // Create API instance
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Example 1: Convert presentation with custom fonts
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("Presentation/uses-custom-font.pptx");
+ settings.setFormat("pdf");
+ settings.setFontsPath("font/ttf"); // Path to the directory containing your fonts
+ settings.setOutputPath("converted/with-custom-fonts.pdf");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(new ConvertDocumentRequest(settings));
+ System.out.println("Document converted successfully: " + result.get(0).getUrl());
+
+ // Example 2: Convert Word document with custom fonts
+ ConvertSettings settings2 = new ConvertSettings();
+ settings2.setFilePath("WordProcessing/custom-typography.docx");
+ settings2.setFormat("pdf");
+ settings2.setFontsPath("font/ttf"); // Path to the directory containing your fonts
+ settings2.setOutputPath("converted/word-with-custom-fonts.pdf");
+
+ // Execute conversion
+ List result2 = apiInstance.convertDocument(new ConvertDocumentRequest(settings2));
+ System.out.println("Word document converted successfully: " + result2.get(0).getUrl());
+ } catch (Exception e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get token from JSON response
+# Now use the token to convert document with custom fonts
+curl -v "https://api.groupdocs.cloud/v2.0/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer YOUR_JWT_TOKEN" \
+-d "{
+ 'FilePath': 'Presentation/uses-custom-font.pptx',
+ 'Format': 'pdf',
+ 'FontsPath': 'font/ttf',
+ 'OutputPath': 'converted/with-custom-fonts.pdf'
+}"
+```
+
+## Advanced Font Handling Techniques
+
+### Font Substitution with OneLoadOptions
+
+For OneNote documents, you can use font substitution to replace specific fonts:
+
+```csharp
+// Create font substitution dictionary
+var fontSubstitutes = new Dictionary
+{
+ {"Tahoma", "Arial"},
+ {"Times New Roman", "Arial"}
+};
+
+// Create load options with font substitution
+var loadOptions = new OneLoadOptions
+{
+ FontSubstitutes = fontSubstitutes
+};
+
+// Prepare convert settings with custom font handling
+var settings = new ConvertSettings
+{
+ FilePath = "Note/sample.one",
+ Format = "pdf",
+ LoadOptions = loadOptions,
+ OutputPath = "converted/note-with-font-substitution.pdf"
+};
+```
+
+### Word Processing Default Font Setting
+
+For Word documents, you can specify a default font to use when a font is missing:
+
+```csharp
+// Set a default font to use when fonts are missing
+var loadOptions = new WordProcessingLoadOptions
+{
+ DefaultFont = "Arial"
+};
+
+// Prepare convert settings with default font
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/document.docx",
+ Format = "pdf",
+ LoadOptions = loadOptions,
+ OutputPath = "converted/with-default-font.pdf"
+};
+```
+
+## Troubleshooting Tips
+
+### Missing Fonts
+Issue: Text appears with incorrect font despite providing custom fonts.Solution:
+- Ensure the font file name matches exactly what's expected by the document
+- Check that the font is in a supported format (.ttf, .otf)
+- Verify the font path is correct and accessible
+
+### Text Misalignment
+Issue: Text is misaligned or runs off the page in the converted document.Solution:
+- Try different conversion options like resolution or page size settings
+- If converting to PDFs, try enabling PDF optimization options
+
+### Font Licensing
+Issue: Concerns about font licensing when embedding fonts.Solution: Ensure you have the proper licenses for the fonts you're using, especially for commercial applications.
+
+## Try It Yourself
+
+Now that you've learned how to use custom fonts, try these exercises:
+
+1. Convert a document that uses a custom corporate font to PDF
+2. Create a font substitution map for a document with unavailable fonts
+3. Compare the output quality between using and not using custom fonts
+4. Try converting a document with multiple custom fonts
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Configure custom font directories for document conversion
+- Maintain the visual fidelity of documents with unique typography
+- Implement font substitution for unavailable fonts
+- Troubleshoot common font-related issues in document conversion
+- Use advanced font handling techniques for different document types
+
+## Next Steps
+
+Now that you can use custom fonts in your conversions, you might want to explore:
+- [Tutorial: Converting to PDF Formats](/advanced-features/convert-to-pdf-formats/)
+- [Tutorial: How to Add Watermarks During Conversion](/advanced-features/add-watermark/)
+- [Tutorial: Converting to Image Formats](/advanced-features/convert-to-image-formats/)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support Forum](https://forum.groupdocs.cloud/c/conversion)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+
+If you have questions about this tutorial, please feel free to post them in our [support forum](https://forum.groupdocs.cloud/c/conversion).
diff --git a/content/conversion/english/advanced-features/csv-conversion-options/_index.md b/content/conversion/english/advanced-features/csv-conversion-options/_index.md
new file mode 100644
index 0000000..c2256cc
--- /dev/null
+++ b/content/conversion/english/advanced-features/csv-conversion-options/_index.md
@@ -0,0 +1,350 @@
+---
+title: How to Convert CSV Documents with Load Options using GroupDocs.Conversion Cloud API
+description: Learn to convert CSV files with precise control over delimiters, encoding, and data formatting using GroupDocs.Conversion Cloud API
+url: /advanced-features/csv-conversion-options/
+weight: 120
+---
+
+# Tutorial: Converting CSV Documents with Load Options
+
+In this tutorial, you'll learn how to convert Comma-Separated Values (CSV) files to various formats using GroupDocs.Conversion Cloud API. You'll master CSV parsing and conversion with full control over delimiters, encoding, and data formatting options.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert CSV files to Excel, PDF, and other formats
+- Customize CSV parsing with delimiter and encoding options
+- Control how CSV data is formatted in the output document
+- Implement both storage-based and stream-based CSV conversions
+- Troubleshoot common CSV conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample CSV files to test conversion
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic CSV to Excel Conversion
+
+Let's start with a simple conversion from CSV to Excel format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'data/sample.csv',
+ 'Format': 'xlsx',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting CSV with Custom Delimiter
+
+CSV files can use various delimiters (commas, semicolons, tabs). Here's how to specify the delimiter:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace CsvConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from CSV to Excel with custom delimiter
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "data/semicolon_separated.csv",
+ Format = "xlsx",
+ // CSV-specific load options
+ LoadOptions = new CsvLoadOptions()
+ {
+ Separator = ";", // Semicolon delimiter
+ ConvertDateTimeData = true, // Convert date strings to Excel dates
+ ConvertNumericData = true // Convert numeric strings to numbers
+ },
+ // Excel-specific convert options (if needed)
+ ConvertOptions = new XlsxConvertOptions(),
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("CSV document converted successfully to Excel: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting CSV to PDF with Encoding Options
+
+When converting to PDF, you might need to specify encoding for international character support:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class CsvToPdfExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for CSV to PDF
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("data/international_data.csv");
+ settings.setFormat("pdf");
+
+ // Set CSV-specific load options
+ CsvLoadOptions loadOptions = new CsvLoadOptions();
+ loadOptions.setSeparator(","); // Comma delimiter
+ loadOptions.setEncoding("utf-8"); // UTF-8 encoding for international characters
+ loadOptions.setConvertDateTimeData(true);
+ loadOptions.setConvertNumericData(true);
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure PDF-specific convert options
+ PdfConvertOptions convertOptions = new PdfConvertOptions();
+ convertOptions.setDpi(300); // High resolution
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("CSV document converted successfully to PDF: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting CSV with Header Row Options
+
+Many CSV files have a header row. Here's how to handle it properly:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "data/with_headers.csv"
+ settings.format = "xlsx"
+
+ # Configure CSV-specific load options
+ load_options = groupdocs_conversion_cloud.CsvLoadOptions()
+ load_options.separator = ","
+ load_options.has_headers = True # Treat first row as column headers
+ load_options.convert_numeric_data = True
+ load_options.convert_date_time_data = True
+
+ settings.load_options = load_options
+
+ # Configure Excel-specific convert options
+ convert_options = groupdocs_conversion_cloud.SpreadsheetConvertOptions()
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"CSV document converted successfully with header processing: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based CSV Conversion
+
+For applications that need to process the converted CSV directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "data/sample.csv",
+ format: "xlsx",
+ loadOptions: {
+ // CSV-specific load options
+ separator: ",",
+ convertDateTimeData: true,
+ convertNumericData: true,
+ hasHeaders: true
+ },
+ convertOptions: {
+ // XLSX-specific convert options if needed
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-csv.xlsx";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`CSV document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## CSV-Specific Load Options
+
+When converting CSV documents, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| Separator | Character used as value delimiter | "," (comma) | Critical for correct field parsing |
+| Encoding | Character encoding of the CSV file | Default encoding | Affects international character display |
+| ConvertNumericData | Convert numeric strings to numbers | false | Improves data usability in Excel |
+| ConvertDateTimeData | Convert date strings to dates | false | Enables date manipulation in Excel |
+| HasHeaders | Whether first row contains column names | false | Controls column header display |
+
+## Troubleshooting Common Issues
+
+### 1. Delimiter Detection Problems
+
+If your CSV isn't parsed correctly:
+- Verify the correct delimiter character (comma, semicolon, tab, etc.)
+- For tab-delimited files, use "\t" as the separator
+- For custom delimiters, specify the exact character
+
+### 2. Encoding Issues
+
+For files with international characters:
+- Specify the correct encoding (UTF-8 is recommended for most cases)
+- For European languages with special characters, consider "ISO-8859-1" or "Windows-1252"
+- For Asian languages, use appropriate encodings like "Shift-JIS" for Japanese
+
+### 3. Data Type Conversion Problems
+
+If numbers or dates appear as text in the output:
+- Set `ConvertNumericData` and `ConvertDateTimeData` to true
+- Ensure date formats in the CSV are recognizable
+- Check if numeric values use a locale-specific decimal separator (comma vs. period)
+
+### 4. Layout and Formatting Considerations
+
+When converting to formats like PDF:
+- Consider setting page size and orientation appropriate for the data width
+- For wide CSV files, landscape orientation may work better
+- Add custom styling or formatting if needed through additional conversion options
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert CSV files to Excel, PDF, and other formats
+- Customizing CSV parsing with delimiter and encoding options
+- Handling header rows and data type conversions
+- Implementing both storage-based and stream-based CSV conversions
+- Troubleshooting common CSV conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a CSV converter that automatically detects the delimiter
+2. Implement a batch conversion utility that processes multiple CSV files with different settings
+3. Build a web form that allows users to upload CSV files and customize conversion options
+4. Create a preview feature that shows how CSV data will be interpreted before conversion
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/email-conversion-options/_index.md b/content/conversion/english/advanced-features/email-conversion-options/_index.md
new file mode 100644
index 0000000..ab41c64
--- /dev/null
+++ b/content/conversion/english/advanced-features/email-conversion-options/_index.md
@@ -0,0 +1,426 @@
+---
+title: Converting Email Documents with Load Options in GroupDocs.Conversion Cloud API Tutorial
+url: /advanced-features/email-conversion-options/
+description: Learn how to convert email messages and storage files to various formats with customization options using GroupDocs.Conversion Cloud API
+weight: 130
+---
+
+# Tutorial: Converting Email Documents with Load Options
+
+In this tutorial, you'll learn how to convert email messages (MSG, EML) and storage files (PST, OST) to other formats using GroupDocs.Conversion Cloud API. You'll master specialized email conversion options including field formatting, address display, and attachment handling.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert email messages to PDF, HTML, and other formats
+- Customize how email fields and metadata are displayed
+- Control email address visibility and formatting
+- Handle embedded images and attachments during conversion
+- Implement both storage-based and stream-based email conversions
+- Troubleshoot common email conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample email files to test conversion (MSG, EML, PST formats)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic Email to PDF Conversion
+
+Let's start with a simple conversion from an MSG file to PDF format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'emails/sample.msg',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting Email to PDF with Field Display Options
+
+Now let's implement a comprehensive example that converts an email to PDF with specific field display options:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace EmailConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from Email to PDF with field display options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "emails/business_message.msg",
+ Format = "pdf",
+ // Email-specific load options
+ LoadOptions = new EmailLoadOptions()
+ {
+ // Header display options
+ DisplayHeader = true,
+ DisplayFrom = true,
+ DisplayTo = true,
+ DisplayCc = true,
+ DisplayBcc = false, // Hide BCC recipients
+ DisplaySubject = true,
+
+ // Email address display options
+ DisplayEmailAddress = true, // Show email addresses
+ DisplayFromEmailAddress = true,
+ DisplayToEmailAddress = true,
+ DisplayCcEmailAddress = true,
+ DisplayBccEmailAddress = false,
+
+ // Time zone and date format options
+ TimeZoneOffset = "-04:00", // Eastern Time
+ ConvertAttachments = true, // Convert attachments
+
+ // Preserve embedded message format if there are embedded emails
+ PreserveEmbeddedMessageFormat = true,
+
+ // Field labels customization
+ FieldLabels = new List()
+ {
+ new FieldLabel() { Field = "From", Label = "Sender" },
+ new FieldLabel() { Field = "To", Label = "Recipients" },
+ new FieldLabel() { Field = "Subject", Label = "Email Topic" }
+ }
+ },
+ // PDF-specific convert options
+ ConvertOptions = new PdfConvertOptions()
+ {
+ Dpi = 300,
+ Width = 1024,
+ Height = 800
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("Email converted successfully to PDF: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting Email to HTML Format
+
+Email to HTML conversion is useful for web applications:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+import java.util.ArrayList;
+
+public class EmailToHtmlExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for Email to HTML
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("emails/newsletter.eml");
+ settings.setFormat("html");
+
+ // Set Email-specific load options
+ EmailLoadOptions loadOptions = new EmailLoadOptions();
+ loadOptions.setDisplayHeader(true);
+ loadOptions.setDisplayFrom(true);
+ loadOptions.setDisplayTo(true);
+ loadOptions.setDisplayCc(true);
+ loadOptions.setDisplaySubject(true);
+
+ // Preserve formatting of HTML content in the email
+ loadOptions.setPreserveOriginalHtml(true);
+
+ // Add custom field labels
+ List fieldLabels = new ArrayList();
+ FieldLabel fromLabel = new FieldLabel();
+ fromLabel.setField("From");
+ fromLabel.setLabel("From");
+ fieldLabels.add(fromLabel);
+
+ FieldLabel toLabel = new FieldLabel();
+ toLabel.setField("To");
+ toLabel.setLabel("To");
+ fieldLabels.add(toLabel);
+
+ loadOptions.setFieldLabels(fieldLabels);
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure HTML-specific convert options
+ WebConvertOptions convertOptions = new WebConvertOptions();
+ convertOptions.setFixedLayout(false); // Fluid layout for responsive design
+ convertOptions.setResourcesEmbedded(true); // Embed images and resources
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Email converted successfully to HTML: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting Email Archive Files (PST/OST)
+
+For handling email archives like PST files, you need to access specific folders:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "emails/archive.pst"
+ settings.format = "pdf"
+
+ # Configure PersonalStorage-specific load options
+ load_options = groupdocs_conversion_cloud.PersonalStorageLoadOptions()
+ load_options.folder = "Inbox" # Specify which folder to convert
+ load_options.depth = 2 # Recursion depth for subfolders
+
+ settings.load_options = load_options
+
+ # Configure PDF-specific convert options
+ convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+ convert_options.dpi = 300
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"Email archive converted successfully to PDF: {len(result)} files created")
+ for i, file in enumerate(result):
+ print(f" - {i+1}: {file.name} ({file.size} bytes)")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based Email Conversion
+
+For applications that need to process the converted email directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "emails/sample.msg",
+ format: "pdf",
+ loadOptions: {
+ // Email-specific load options
+ displayHeader: true,
+ displayFrom: true,
+ displayTo: true,
+ displayCc: true,
+ displaySubject: true,
+
+ displayEmailAddress: true,
+ preserveOriginalHtml: true,
+ convertAttachments: false // Don't convert attachments
+ },
+ convertOptions: {
+ // PDF-specific convert options
+ dpi: 300
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-email.pdf";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`Email document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## Email-Specific Load Options
+
+When converting email documents, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| DisplayHeader | Show email header | true | Controls header visibility |
+| DisplayFrom | Show From field | true | Controls From field visibility |
+| DisplayTo | Show To field | true | Controls To field visibility |
+| DisplayCc | Show Cc field | true | Controls Cc field visibility |
+| DisplayBcc | Show Bcc field | true | Controls Bcc field visibility |
+| DisplaySubject | Show Subject field | true | Controls Subject field visibility |
+| DisplayEmailAddress | Show email addresses | true | Controls whether addresses are shown |
+| TimeZoneOffset | Time zone for dates | System default | Affects how dates are displayed |
+| ConvertAttachments | Process attachments | false | Controls attachment handling |
+| PreserveEmbeddedMessageFormat | Keep format for embedded emails | false | Affects nested email display |
+| PreserveOriginalHtml | Keep original HTML formatting | false | Affects HTML content display |
+| FieldLabels | Custom labels for fields | Standard labels | Changes field labels in output |
+
+## Email Storage Load Options
+
+For PST/OST files, these additional options are available:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| Folder | Folder to process | Root folder | Controls which emails are converted |
+| Depth | Subfolder recursion depth | 0 (no recursion) | Controls subfolder handling |
+
+## Troubleshooting Common Issues
+
+### 1. Email Field Display Problems
+
+If email fields aren't displaying correctly:
+- Check the corresponding DisplayXxx options (DisplayFrom, DisplayTo, etc.)
+- Verify that you're setting the correct options for your needs
+- For custom field labels, ensure the Field property matches a valid email field
+
+### 2. Address Format Issues
+
+If email addresses aren't showing as expected:
+- Adjust the DisplayEmailAddress and related options
+- For privacy, you can hide email addresses by setting these options to false
+- Consider customizing the field labels for clearer presentation
+
+### 3. HTML Content Preservation
+
+For emails with rich HTML content:
+- Set PreserveOriginalHtml to true to maintain the original formatting
+- When converting to HTML format, ensure ResourcesEmbedded is set to include images
+- If HTML content looks broken, try different conversion formats (PDF often works best)
+
+### 4. Attachment Handling
+
+When dealing with email attachments:
+- Set ConvertAttachments to true if you want attachments included in the output
+- Be aware that large attachments can significantly increase processing time
+- For PST files with many emails, consider processing folders separately
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert email messages and storage files to various formats
+- Customizing how email fields and metadata are displayed
+- Controlling email address visibility and formatting
+- Handling embedded images, HTML content, and attachments
+- Implementing both storage-based and stream-based email conversions
+- Troubleshooting common email conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create an email archiving system that converts messages to PDF for storage
+2. Implement a batch conversion utility that processes multiple email files with consistent formatting
+3. Build a web application that allows users to convert email messages while controlling privacy settings
+4. Create a report generator that extracts specific information from email archives
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/onenote-conversion-options/_index.md b/content/conversion/english/advanced-features/onenote-conversion-options/_index.md
new file mode 100644
index 0000000..7ab715c
--- /dev/null
+++ b/content/conversion/english/advanced-features/onenote-conversion-options/_index.md
@@ -0,0 +1,387 @@
+---
+title: Converting OneNote Documents Tutorial with GroupDocs.Conversion Cloud API
+description: Learn how to convert OneNote documents to other formats with font and formatting options using GroupDocs.Conversion Cloud API
+url: /advanced-features/onenote-conversion-options/
+weight: 140
+---
+
+# Tutorial: Converting OneNote Documents with Load Options
+
+In this tutorial, you'll learn how to convert Microsoft OneNote documents to other formats using GroupDocs.Conversion Cloud API. You'll master specialized conversion options for handling notebooks and sections with proper formatting and font control.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert OneNote files (ONE) to PDF, images, and other formats
+- Customize font and formatting options during conversion
+- Handle font substitution for consistent appearance
+- Implement both storage-based and stream-based OneNote conversions
+- Troubleshoot common OneNote conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample OneNote files to test conversion
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic OneNote to PDF Conversion
+
+Let's start with a simple conversion from a OneNote file to PDF format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'note/sample.one',
+ 'Format': 'pdf',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting OneNote to PDF with Font Options
+
+Now let's implement a comprehensive example that converts a OneNote document to PDF with font customization:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace OneNoteConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Create a dictionary for font substitution
+ var fontSubstitutes = new Dictionary
+ {
+ { "Calibri", "Arial" },
+ { "Cambria", "Times New Roman" }
+ };
+
+ // Set up conversion from OneNote to PDF with font options
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "note/project_notes.one",
+ Format = "pdf",
+ // OneNote-specific load options
+ LoadOptions = new OneLoadOptions()
+ {
+ DefaultFont = "Arial", // Default font if original is missing
+ FontSubstitutes = fontSubstitutes // Font substitution mapping
+ },
+ // PDF-specific convert options
+ ConvertOptions = new PdfConvertOptions()
+ {
+ Dpi = 300,
+ Width = 1024,
+ Height = 768,
+ CenterWindow = true,
+ Grayscale = false, // Keep colors
+ BookmarksOutlineLevel = 1 // Include headings in bookmarks
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("OneNote document converted successfully to PDF: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting OneNote to Image Format
+
+Converting OneNote documents to images can be useful for creating thumbnails or web-friendly previews:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+
+public class OneNoteToImageExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for OneNote to PNG
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("note/meeting_notes.one");
+ settings.setFormat("png");
+
+ // Set OneNote-specific load options
+ OneLoadOptions loadOptions = new OneLoadOptions();
+ loadOptions.setDefaultFont("Segoe UI"); // Default font
+
+ // Create a font substitution map
+ Map fontSubs = new HashMap();
+ fontSubs.put("Segoe UI", "Arial");
+ fontSubs.put("Calibri", "Helvetica");
+ loadOptions.setFontSubstitutes(fontSubs);
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure PNG-specific convert options
+ PngConvertOptions convertOptions = new PngConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(0); // All pages
+ convertOptions.setDpi(300);
+ convertOptions.setBackgroundColor("white");
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("OneNote document converted successfully to PNG: " + result.size() + " images");
+ for (StoredConvertedResult file : result) {
+ System.out.println(" - " + file.getName() + " (" + file.getSize() + " bytes)");
+ }
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting OneNote with Text and Font Formatting
+
+For formats that support text formatting, you can preserve the structure of your OneNote documents:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "note/research_notes.one"
+ settings.format = "docx" # Convert to Word for rich text preservation
+
+ # Configure OneNote-specific load options
+ load_options = groupdocs_conversion_cloud.OneLoadOptions()
+ load_options.default_font = "Arial"
+
+ # Create a font substitution dictionary
+ font_substitutes = {
+ "Calibri": "Arial",
+ "Cambria": "Times New Roman",
+ "Comic Sans MS": "Arial" # Replace Comic Sans
+ }
+ load_options.font_substitutes = font_substitutes
+
+ settings.load_options = load_options
+
+ # Configure Word-specific convert options
+ convert_options = groupdocs_conversion_cloud.WordProcessingConvertOptions()
+ convert_options.from_page = 1
+ convert_options.pages_count = 0 # All pages
+ convert_options.dpi = 300
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"OneNote document converted successfully to DOCX: {result[0].url}")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Stream-Based OneNote Conversion
+
+For applications that need to process the converted document directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "note/sample.one",
+ format: "pdf",
+ loadOptions: {
+ // OneNote-specific load options
+ defaultFont: "Arial",
+ fontSubstitutes: {
+ "Calibri": "Arial",
+ "Cambria": "Times New Roman"
+ }
+ },
+ convertOptions: {
+ // PDF-specific convert options
+ dpi: 300,
+ bookmarksOutlineLevel: 1
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-onenote.pdf";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`OneNote document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## OneNote-Specific Load Options
+
+When converting OneNote documents, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| DefaultFont | Default font to use if original is missing | System default | Ensures text displays even if fonts are missing |
+| FontSubstitutes | Dictionary mapping fonts to substitutions | Empty | Enables controlled font replacement |
+
+## Troubleshooting Common Issues
+
+### 1. Font Rendering Problems
+
+If text doesn't render correctly:
+- Set a widely available DefaultFont (Arial, Times New Roman)
+- Use FontSubstitutes to map specific OneNote fonts to available alternatives
+- If special characters appear as boxes, ensure you're using a font with needed character support
+
+### 2. Image and Layout Issues
+
+If images or layouts don't convert well:
+- Try converting to PDF first, as it typically preserves layout better
+- For image formats, adjust DPI to balance quality and file size
+- Consider page size settings that match the original OneNote aspect ratio
+
+### 3. Complex Content Handling
+
+For notebooks with complex content:
+- Test different output formats to find the best match for your content
+- Consider converting to multiple formats based on content type
+- For complex tables or embedded content, PDF usually gives the best results
+
+### 4. Section and Page Structure
+
+When preserving notebook structure:
+- Use bookmarks (in PDF) to maintain section hierarchy
+- For Word format output, heading styles help maintain organization
+- Consider converting sections individually for more control
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert OneNote documents to PDF, images, and other formats
+- Customizing font handling with substitution and defaults
+- Controlling formatting and layout during conversion
+- Implementing both storage-based and stream-based OneNote conversions
+- Troubleshooting common OneNote conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a batch conversion utility that processes multiple OneNote files with consistent font handling
+2. Implement a web-based OneNote viewer that converts sections to responsive HTML
+3. Build a reporting system that extracts and converts specific OneNote sections to PDF
+4. Create a comparison tool that shows how different output formats preserve OneNote content
+
+## Next Tutorial
+
+Ready to learn more? Continue with our [Tutorial: Converting PDF Documents with Custom Options](/advanced-features/pdf-conversion-options) to master PDF handling with annotations and security options.
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/advanced-features/pdf-conversion-options/_index.md b/content/conversion/english/advanced-features/pdf-conversion-options/_index.md
new file mode 100644
index 0000000..a5b86c7
--- /dev/null
+++ b/content/conversion/english/advanced-features/pdf-conversion-options/_index.md
@@ -0,0 +1,415 @@
+---
+title: How to Convert PDF Documents with Custom Options using GroupDocs.Conversion Cloud API
+description: Learn to convert PDF documents with advanced options for handling annotations, security, and formatting using GroupDocs.Conversion Cloud API
+url: /advanced-features/pdf-conversion-options/
+weight: 150
+---
+
+# Tutorial: Converting PDF Documents with Custom Options
+
+In this tutorial, you'll learn how to convert PDF documents to various formats using GroupDocs.Conversion Cloud API. You'll master specialized PDF conversion options including annotation handling, security credentials, and advanced formatting control.
+
+## Learning Objectives
+
+By the end of this tutorial, you will be able to:
+- Convert PDF files to Word, Excel, images, and other formats
+- Handle PDF security with password-protected documents
+- Control annotation visibility during conversion
+- Manage PDF form fields and embedded content
+- Implement both storage-based and stream-based PDF conversions
+- Troubleshoot common PDF conversion challenges
+
+## Prerequisites
+
+Before starting this tutorial, you need:
+1. A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+2. Your Client ID and Client Secret credentials
+3. Basic understanding of REST API concepts
+4. Development environment with your preferred programming language set up
+5. Sample PDF files to test conversion (including some with annotations, form fields, and password protection)
+
+## Implementation Steps
+
+### Step 1: Authentication with GroupDocs.Conversion Cloud API
+
+Before performing any operations, we need to authenticate with the API using your Client ID and Client Secret.
+
+#### Try it yourself
+
+First, let's obtain a JWT access token using cURL:
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+```
+
+Make sure to replace `YOUR_CLIENT_ID` and `YOUR_CLIENT_SECRET` with your actual credentials.
+
+### Step 2: Basic PDF to Word Conversion
+
+Let's start with a simple conversion from a PDF file to DOCX format:
+
+#### Try it yourself
+
+Using cURL:
+
+```bash
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+-H "accept: application/json" \
+-H "authorization: Bearer YOUR_JWT_TOKEN" \
+-H "Content-Type: application/json" \
+-d "{
+ 'FilePath': 'documents/sample.pdf',
+ 'Format': 'docx',
+ 'OutputPath': 'converted'
+ }"
+```
+
+Replace `YOUR_JWT_TOKEN` with the actual token received in Step 1.
+
+### Step 3: Converting PDF to Word with Annotation Control
+
+Now let's implement a comprehensive example that converts a PDF to Word while handling annotations:
+
+```csharp
+// C# SDK Example
+using System;
+using System.Collections.Generic;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace PdfConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Configure API client
+ var configuration = new Configuration("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Set up conversion from PDF to Word with annotation control
+ var settings = new ConvertSettings
+ {
+ StorageName = "MyStorage",
+ FilePath = "documents/annotated.pdf",
+ Format = "docx",
+ // PDF-specific load options
+ LoadOptions = new PdfLoadOptions()
+ {
+ Password = "", // If PDF is password-protected
+ HidePdfAnnotations = true, // Hide annotations in output
+ FlattenAllFields = true, // Flatten form fields
+ RemoveEmbeddedFiles = true // Remove embedded files for cleaner output
+ },
+ // Word-specific convert options
+ ConvertOptions = new DocxConvertOptions()
+ {
+ FromPage = 1,
+ PagesCount = 0, // All pages
+ Dpi = 300
+ },
+ OutputPath = "converted"
+ };
+
+ // Execute conversion
+ List response = apiInstance.ConvertDocument(
+ new ConvertDocumentRequest(settings));
+
+ Console.WriteLine("PDF document converted successfully to DOCX: " + response[0].Url);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+ }
+ }
+}
+```
+
+### Step 4: Converting Password-Protected PDF Documents
+
+For PDFs that require a password to open:
+
+```java
+// Java SDK Example
+import com.groupdocs.cloud.conversion.api.*;
+import com.groupdocs.cloud.conversion.client.ApiException;
+import com.groupdocs.cloud.conversion.model.*;
+import com.groupdocs.cloud.conversion.model.requests.*;
+import java.util.List;
+
+public class ProtectedPdfExample {
+ public static void main(String[] args) {
+ // Configure API client
+ String clientId = "YOUR_CLIENT_ID";
+ String clientSecret = "YOUR_CLIENT_SECRET";
+ Configuration configuration = new Configuration(clientId, clientSecret);
+ ConvertApi apiInstance = new ConvertApi(configuration);
+
+ try {
+ // Prepare convert settings for protected PDF
+ ConvertSettings settings = new ConvertSettings();
+ settings.setFilePath("documents/secured.pdf");
+ settings.setFormat("docx");
+
+ // Set PDF-specific load options with password
+ PdfLoadOptions loadOptions = new PdfLoadOptions();
+ loadOptions.setPassword("yourpassword"); // Password to open the PDF
+ loadOptions.setFlattenAllFields(true);
+ loadOptions.setHidePdfAnnotations(true);
+
+ settings.setLoadOptions(loadOptions);
+
+ // Configure Word-specific convert options
+ WordProcessingConvertOptions convertOptions = new WordProcessingConvertOptions();
+ convertOptions.setFromPage(1);
+ convertOptions.setPagesCount(0); // All pages
+ convertOptions.setDpi(300);
+
+ settings.setConvertOptions(convertOptions);
+ settings.setOutputPath("converted");
+
+ // Execute conversion
+ List result = apiInstance.convertDocument(
+ new ConvertDocumentRequest(settings));
+
+ System.out.println("Protected PDF document converted successfully: " + result.get(0).getUrl());
+ } catch (ApiException e) {
+ System.err.println("Exception when calling ConvertApi: " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Step 5: Converting PDF to Image Format with Page Control
+
+Converting PDF documents to images gives you precise control over rendering:
+
+```python
+# Python SDK Example
+import groupdocs_conversion_cloud
+from groupdocs_conversion_cloud.models.requests import ConvertDocumentRequest
+
+# Configure API client
+client_id = "YOUR_CLIENT_ID"
+client_secret = "YOUR_CLIENT_SECRET"
+api_instance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+try:
+ # Prepare conversion settings
+ settings = groupdocs_conversion_cloud.ConvertSettings()
+ settings.file_path = "documents/multipage.pdf"
+ settings.format = "jpg"
+
+ # Configure PDF-specific load options
+ load_options = groupdocs_conversion_cloud.PdfLoadOptions()
+ load_options.password = "" # If PDF is protected
+ load_options.hide_pdf_annotations = True
+ load_options.remove_embedded_files = True
+
+ settings.load_options = load_options
+
+ # Configure JPG-specific convert options
+ convert_options = groupdocs_conversion_cloud.JpegConvertOptions()
+ convert_options.from_page = 2 # Start from second page
+ convert_options.pages_count = 3 # Convert three pages
+ convert_options.dpi = 300 # High resolution
+ convert_options.quality = 100 # Maximum quality
+ convert_options.grayscale = False # Color image
+
+ settings.convert_options = convert_options
+ settings.output_path = "converted"
+
+ # Execute conversion
+ request = ConvertDocumentRequest(settings)
+ result = api_instance.convert_document(request)
+
+ print(f"PDF document converted successfully to JPG: {len(result)} images")
+ for i, image in enumerate(result):
+ print(f" - Page {i+2}: {image.name} ({image.size} bytes)")
+except groupdocs_conversion_cloud.ApiException as e:
+ print(f"Exception when calling ConvertApi: {e}")
+```
+
+### Step 6: Converting PDF to Excel with Table Recognition
+
+PDF documents often contain tabular data that's valuable in spreadsheet format:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/financial_report.pdf",
+ format: "xlsx",
+ loadOptions: {
+ // PDF-specific load options
+ password: "", // If PDF is protected
+ hidePdfAnnotations: true,
+ flattenAllFields: true
+ },
+ convertOptions: {
+ // Excel-specific convert options
+ fromPage: 1,
+ pagesCount: 0, // All pages
+ zoom: 100
+ },
+ outputPath: "converted"
+};
+
+// Execute conversion
+apiInstance.convertDocument({ convertSettings: settings })
+ .then((result) => {
+ console.log(`PDF document converted successfully to Excel: ${result[0].url}`);
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+### Step 7: Stream-Based PDF Conversion
+
+For applications that need to process the converted document directly:
+
+```javascript
+// Node.js SDK Example
+const { ConvertApi, Configuration } = require("groupdocs-conversion-cloud");
+const fs = require("fs");
+
+// Configure API client
+const clientId = "YOUR_CLIENT_ID";
+const clientSecret = "YOUR_CLIENT_SECRET";
+const config = new Configuration(clientId, clientSecret);
+const apiInstance = new ConvertApi(config);
+
+// Prepare conversion settings
+const settings = {
+ filePath: "documents/sample.pdf",
+ format: "docx",
+ loadOptions: {
+ // PDF-specific load options
+ hidePdfAnnotations: true,
+ flattenAllFields: true
+ },
+ convertOptions: {
+ // DOCX-specific convert options
+ dpi: 300
+ },
+ // Set outputPath to null for stream output
+ outputPath: null
+};
+
+// Execute conversion
+apiInstance.convertDocumentDownload({ convertSettings: settings })
+ .then((result) => {
+ // Save the stream to a file
+ const fileName = "./converted-pdf.docx";
+ const writeStream = fs.createWriteStream(fileName);
+
+ result.pipe(writeStream);
+
+ writeStream.on("finish", () => {
+ console.log(`PDF document converted and saved to ${fileName}`);
+ });
+ })
+ .catch((error) => {
+ console.log(`Error: ${error.message}`);
+ });
+```
+
+## PDF-Specific Load Options
+
+When converting PDF documents, you can leverage these specialized options:
+
+| Option | Description | Default | Impact |
+|--------|-------------|---------|--------|
+| Password | Document open password | null | Required for protected PDFs |
+| HidePdfAnnotations | Hide annotations in output | false | Controls annotation visibility |
+| FlattenAllFields | Flatten form fields | false | Controls form field appearance |
+| RemoveEmbeddedFiles | Remove embedded files | false | Controls embedded content |
+| ExtractOCRText | Extract OCR text when available | true | Controls text extraction method |
+| EnableLayeredRendering | Enable layer rendering | false | Controls layer handling |
+
+## Troubleshooting Common Issues
+
+### 1. Password and Security Problems
+
+If you encounter issues with protected PDFs:
+- Ensure the password is correct and provided in the correct case
+- If a document has permission restrictions, you might need owner password
+- For highly secured PDFs, some restrictions might prevent certain types of conversion
+
+### 2. Annotation Handling Issues
+
+When dealing with annotated PDFs:
+- Use HidePdfAnnotations to control whether annotations appear in output
+- If annotations appear unexpectedly, ensure this option is set to true
+- For format-specific annotation conversion, test different target formats
+
+### 3. Form Field Preservation
+
+For PDFs with forms:
+- Use FlattenAllFields to control whether fields become regular content
+- When converting to editable formats, you might need to set this to false
+- Test form field handling with different destination formats
+
+### 4. Image Quality Challenges
+
+When converting PDF to images:
+- Adjust DPI for better quality (300 DPI is good for most purposes)
+- For JPG conversion, set quality to a higher value (90-100)
+- For text clarity, enable anti-aliasing if available
+
+### 5. Layout Preservation Issues
+
+For complex layouts:
+- PDF to Word/Excel conversion might not preserve all formatting
+- Try PDF to PDF/A conversion first for consistent results
+- Consider using PDF to image conversion for exact visual fidelity
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to convert PDF documents to various formats including Word, Excel, and images
+- Handling password-protected PDF documents
+- Controlling annotation visibility and form field handling
+- Managing embedded content during conversion
+- Implementing both storage-based and stream-based PDF conversions
+- Troubleshooting common PDF conversion challenges
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a batch conversion utility that processes multiple PDF files with consistent settings
+2. Implement a web form that allows users to upload PDFs and choose conversion options
+3. Build a system that extracts tables from PDFs and converts them to Excel with proper formatting
+4. Create a PDF processing pipeline that handles annotations differently based on their type
+
+## Additional Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+Have questions about this tutorial? Feel free to reach out on our [forum](https://forum.groupdocs.cloud/c/conversion/11) for support.
diff --git a/content/conversion/english/data-organization/_index.md b/content/conversion/english/data-organization/_index.md
new file mode 100644
index 0000000..9845ee9
--- /dev/null
+++ b/content/conversion/english/data-organization/_index.md
@@ -0,0 +1,66 @@
+---
+title: GroupDocs.Conversion Cloud API Document Data Organization Techniques Tutorials
+url: /data-organization/
+weight: 1
+description: Learn essential document data organization techniques with our hands-on tutorials for GroupDocs.Conversion Cloud API
+---
+
+# GroupDocs.Conversion Cloud API Document Data Organization Techniques Tutorials
+
+Welcome to our hands-on tutorial series for developers working with GroupDocs.Conversion Cloud API! This comprehensive learning path guides you through essential data organization techniques from basic to advanced levels. Each tutorial provides practical knowledge to help you efficiently manage document data within your applications.
+
+## Learning Path
+
+Our tutorials follow a structured progression, allowing you to build your skills step by step:
+
+1. Beginner Level: Understand the fundamental data structures and organization principles
+2. Intermediate Level: Learn to manipulate and optimize data for different document types
+3. Advanced Level: Master complex conversion scenarios and custom data handling techniques
+
+## Available Tutorials
+
+### Beginner Tutorials
+
+- [Tutorial: How to Work with Conversion Settings](/data-organization/conversion-settings/) - Learn to configure and apply conversion settings to control document processing with step-by-step instructions.
+- [Tutorial: Understanding Load Options in Document Conversion](/data-organization/load-options/) - Master the techniques for loading different document formats with appropriate options for optimal conversion results.
+- [Tutorial: Working with Convert Options](/data-organization/convert-options/) - Discover how to specify format-specific conversion parameters to achieve precise output for various document types.
+
+### Intermediate Tutorials
+
+- [Tutorial: Processing Conversion Results](/data-organization/conversion-result/) - Learn effective methods for handling and organizing conversion output across multiple document types.
+- [Tutorial: Implementing Format-Specific Conversion Options](/data-organization/format-specific-options/) - Master techniques for optimizing conversion settings for particular document formats.
+
+## Prerequisites
+
+Before beginning these tutorials, you should have:
+
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps) (free trial available)
+- Basic understanding of RESTful APIs
+- Familiarity with your programming language of choice (examples provided in cURL, Python, Java, and C#)
+- Development environment set up for your preferred programming language
+
+## Getting Started
+
+Each tutorial includes:
+- Clear learning objectives
+- Estimated completion time
+- Detailed step-by-step instructions
+- Working code examples
+- Practical exercises to reinforce concepts
+- Troubleshooting tips for common issues
+
+We recommend following the tutorials in sequence, as each builds on knowledge gained in previous lessons.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about these tutorials? Need clarification on a particular topic? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
diff --git a/content/conversion/english/data-organization/conversion-result/_index.md b/content/conversion/english/data-organization/conversion-result/_index.md
new file mode 100644
index 0000000..1f7c66a
--- /dev/null
+++ b/content/conversion/english/data-organization/conversion-result/_index.md
@@ -0,0 +1,599 @@
+---
+title: Processing Conversion Results Tutorial
+url: /data-organization/conversion-result/
+weight: 40
+description: Learn effective techniques for handling and organizing document conversion output with this hands-on tutorial for GroupDocs.Conversion Cloud API
+---
+
+# Tutorial: Processing Conversion Results
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- What ConversionResult is and how to interpret it
+- How to process conversion output efficiently
+- Techniques for handling multi-page and multi-format conversions
+- Best practices for managing converted documents in cloud storage
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with JSON data structures
+- Completion of the previous tutorials in this series (recommended)
+- A development environment set up for your preferred language (examples provided in cURL, Python, Java, and C#)
+
+## What is ConversionResult?
+
+ConversionResult is the data structure returned by the GroupDocs.Conversion Cloud API after a successful conversion operation. It provides critical information about the converted document(s), including:
+
+- File names of the converted documents
+- File sizes
+- URLs to access the converted documents in cloud storage
+
+The ConversionResult is returned as an array, since a single conversion request can produce multiple output files (e.g., when converting multiple pages of a document to separate image files).
+
+## Understanding the ConversionResult Structure
+
+Let's examine the basic structure of a ConversionResult:
+
+```json
+[
+ {
+ "name": "converted-document.pdf",
+ "size": 17958,
+ "url": "converted/converted-document.pdf"
+ },
+ {
+ "name": "converted-document-page-1.jpg",
+ "size": 45327,
+ "url": "converted/converted-document-page-1.jpg"
+ },
+ {
+ "name": "converted-document-page-2.jpg",
+ "size": 39481,
+ "url": "converted/converted-document-page-2.jpg"
+ }
+]
+```
+
+Each item in the array contains:
+
+| Field | Description |
+|-------|-------------|
+| name | The name of the converted file |
+| size | The size of the file in bytes |
+| url | The relative path to the file in your cloud storage |
+
+## Step 1: Basic Processing of ConversionResult
+
+Let's start with a simple example of processing a ConversionResult:
+
+```python
+# Tutorial Code Example: Basic ConversionResult Processing
+# Assuming 'result' contains the ConversionResult array
+
+# Print information about each converted file
+for file in result:
+ print(f"File: {file['name']}")
+ print(f"Size: {file['size']} bytes")
+ print(f"URL: {file['url']}")
+ print("---")
+
+# Calculate total size of all converted files
+total_size = sum(file['size'] for file in result)
+print(f"Total conversion size: {total_size} bytes")
+print(f"Number of files created: {len(result)}")
+```
+
+### Try it yourself
+
+Write code to process a ConversionResult and categorize files by their extension:
+
+```python
+# Exercise: Categorize ConversionResult files by extension
+# Your code here:
+def categorize_by_extension(result):
+ extensions = {}
+
+ for file in result:
+ # Extract extension from filename
+ name_parts = file['name'].split('.')
+ if len(name_parts) > 1:
+ ext = name_parts[-1].lower()
+ if ext not in extensions:
+ extensions[ext] = []
+ extensions[ext].append(file)
+
+ # Print summary
+ for ext, files in extensions.items():
+ print(f"Extension .{ext}: {len(files)} files, {sum(f['size'] for f in files)} bytes total")
+
+ return extensions
+
+# Usage
+file_categories = categorize_by_extension(result)
+```
+
+## Step 2: Working with File Paths and URLs
+
+The `url` field in ConversionResult provides the relative path to the file in your cloud storage. To access or download these files, you'll need to understand how to work with these URLs.
+
+```python
+# Tutorial Code Example: Working with ConversionResult URLs
+import requests
+
+# Assuming 'result' contains the ConversionResult array
+# and 'access_token' contains your API access token
+
+base_url = "https://api.groupdocs.cloud/v2.0/conversion/storage/file/"
+
+def download_converted_file(file_info, destination_folder="downloads/"):
+ """Download a converted file using its URL from the ConversionResult"""
+ import os
+
+ # Create destination folder if it doesn't exist
+ if not os.path.exists(destination_folder):
+ os.makedirs(destination_folder)
+
+ # Construct full API URL
+ file_url = base_url + file_info["url"]
+
+ # Send request to download file
+ headers = {"Authorization": f"Bearer {access_token}"}
+ response = requests.get(file_url, headers=headers, stream=True)
+
+ if response.status_code == 200:
+ # Save file to local destination
+ local_path = os.path.join(destination_folder, file_info["name"])
+ with open(local_path, "wb") as f:
+ for chunk in response.iter_content(chunk_size=8192):
+ f.write(chunk)
+ print(f"Downloaded: {file_info['name']} to {local_path}")
+ return local_path
+ else:
+ print(f"Failed to download {file_info['name']}: {response.status_code}")
+ return None
+
+# Download all converted files
+for file in result:
+ download_converted_file(file)
+```
+
+### Try it yourself
+
+Write a function to download only the largest file from a ConversionResult:
+
+```python
+# Exercise: Download only the largest file from ConversionResult
+# Your code here:
+def download_largest_file(result, destination_folder="downloads/"):
+ """Find and download only the largest file from the ConversionResult"""
+ if not result:
+ print("No files to download")
+ return None
+
+ # Find the largest file
+ largest_file = max(result, key=lambda x: x["size"])
+ print(f"Largest file is {largest_file['name']} ({largest_file['size']} bytes)")
+
+ # Download the file
+ return download_converted_file(largest_file, destination_folder)
+
+# Usage
+largest_file_path = download_largest_file(result)
+```
+
+## Step 3: Handling Multi-Page Conversions
+
+When converting multi-page documents to formats like images, you'll receive multiple files in the ConversionResult (one for each page). Let's see how to handle this scenario:
+
+```python
+# Tutorial Code Example: Handling Multi-Page Conversion Results
+def organize_pages_by_document(result):
+ """Organize conversion results by document and page number"""
+ documents = {}
+
+ for file in result:
+ name = file["name"]
+
+ # Check if this is a page file (contains "-page-" in the name)
+ if "-page-" in name:
+ # Parse document name and page number
+ base_name, page_info = name.split("-page-")
+ page_num = int(page_info.split(".")[0])
+
+ # Add to documents dictionary
+ if base_name not in documents:
+ documents[base_name] = {"pages": {}}
+
+ documents[base_name]["pages"][page_num] = file
+ else:
+ # This is a main document file
+ doc_name = name.split(".")[0]
+ if doc_name not in documents:
+ documents[doc_name] = {"main_file": file, "pages": {}}
+ else:
+ documents[doc_name]["main_file"] = file
+
+ return documents
+
+# Usage example
+organized_results = organize_pages_by_document(result)
+
+# Process each document's pages in order
+for doc_name, doc_info in organized_results.items():
+ print(f"Document: {doc_name}")
+
+ if "main_file" in doc_info:
+ print(f"Main file: {doc_info['main_file']['name']} ({doc_info['main_file']['size']} bytes)")
+
+ print("Pages:")
+ # Sort pages by number
+ sorted_pages = sorted(doc_info["pages"].items())
+ for page_num, page_file in sorted_pages:
+ print(f" Page {page_num}: {page_file['name']} ({page_file['size']} bytes)")
+```
+
+This code organizes conversion results by document and page number, making it easier to process multi-page conversions systematically.
+
+### Batch Processing Large Documents
+
+For very large documents, you might need to process pages in batches:
+
+```python
+# Tutorial Code Example: Batch Processing Large Documents
+def batch_process_pages(organized_results, batch_size=10, process_func=None):
+ """Process document pages in batches"""
+ if process_func is None:
+ # Default processing function just prints info
+ process_func = lambda page_files: print(f"Processing batch of {len(page_files)} pages")
+
+ for doc_name, doc_info in organized_results.items():
+ print(f"Processing document: {doc_name}")
+
+ # Get all pages sorted by page number
+ all_pages = [page for _, page in sorted(doc_info["pages"].items())]
+ total_pages = len(all_pages)
+
+ # Process pages in batches
+ for i in range(0, total_pages, batch_size):
+ batch = all_pages[i:i+batch_size]
+ print(f"Processing batch {i//batch_size + 1}, pages {i+1}-{min(i+batch_size, total_pages)}")
+ process_func(batch)
+
+# Example usage with a custom processing function
+def my_batch_processor(page_files):
+ # Process a batch of page files
+ print(f"Processing {len(page_files)} pages")
+ total_batch_size = sum(p["size"] for p in page_files)
+ print(f"Total batch size: {total_batch_size} bytes")
+ # Add your processing logic here...
+
+batch_process_pages(organized_results, batch_size=5, process_func=my_batch_processor)
+```
+
+## Step 4: Implementing Complete Solutions
+
+Let's see how to implement ConversionResult processing with the API in different languages:
+
+### Python Example
+
+```python
+# Tutorial Code Example: Complete ConversionResult Processing in Python
+import groupdocs_conversion_cloud
+import os
+
+# Configure the API client
+configuration = groupdocs_conversion_cloud.Configuration(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET"
+)
+api_client = groupdocs_conversion_cloud.ApiClient(configuration)
+convert_api = groupdocs_conversion_cloud.ConvertApi(api_client)
+file_api = groupdocs_conversion_cloud.FileApi(api_client)
+
+# Create conversion settings
+settings = groupdocs_conversion_cloud.ConvertSettings()
+settings.file_path = "documents/multipage.docx"
+settings.format = "jpeg"
+settings.output_path = "converted/"
+
+# Execute conversion
+result = convert_api.convert(settings)
+print(f"Conversion completed: {len(result)} files generated")
+
+# Process and download results
+download_folder = "downloads/"
+if not os.path.exists(download_folder):
+ os.makedirs(download_folder)
+
+# Organize results by page
+pages = {}
+for file_info in result:
+ print(f"File: {file_info.name}, Size: {file_info.size} bytes, URL: {file_info.url}")
+
+ # Extract page number from filename
+ if "-page-" in file_info.name:
+ page_num = int(file_info.name.split("-page-")[1].split(".")[0])
+ pages[page_num] = file_info
+
+ # Download the file
+ request = groupdocs_conversion_cloud.DownloadFileRequest(file_info.url)
+ response = file_api.download_file(request)
+
+ # Save to local file
+ output_path = os.path.join(download_folder, file_info.name)
+ with open(output_path, 'wb') as f:
+ f.write(response)
+
+ print(f"Downloaded to {output_path}")
+
+# Process pages in order
+for page_num in sorted(pages.keys()):
+ page_file = pages[page_num]
+ print(f"Processing page {page_num}: {page_file.name}")
+ # Add your page processing logic here...
+```
+
+### C# Example
+
+```csharp
+// Tutorial Code Example: Complete ConversionResult Processing in C#
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using GroupDocs.Conversion.Cloud.Sdk;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Configure the API client
+var configuration = new Configuration
+{
+ ClientId = "YOUR_CLIENT_ID",
+ ClientSecret = "YOUR_CLIENT_SECRET"
+};
+
+var convertApi = new ConvertApi(configuration);
+var fileApi = new FileApi(configuration);
+
+// Create conversion settings
+var settings = new ConvertSettings
+{
+ FilePath = "documents/multipage.docx",
+ Format = "jpeg",
+ OutputPath = "converted/"
+};
+
+// Execute conversion
+var result = convertApi.Convert(new ConvertRequest(settings));
+Console.WriteLine($"Conversion completed: {result.Count} files generated");
+
+// Process and download results
+string downloadFolder = "downloads";
+if (!Directory.Exists(downloadFolder))
+{
+ Directory.CreateDirectory(downloadFolder);
+}
+
+// Organize results by page
+var pages = new Dictionary();
+foreach (var fileInfo in result)
+{
+ Console.WriteLine($"File: {fileInfo.Name}, Size: {fileInfo.Size} bytes, URL: {fileInfo.Url}");
+
+ // Extract page number from filename
+ if (fileInfo.Name.Contains("-page-"))
+ {
+ string[] parts = fileInfo.Name.Split(new[] { "-page-" }, StringSplitOptions.None);
+ string pageNumStr = parts[1].Split('.')[0];
+ if (int.TryParse(pageNumStr, out int pageNum))
+ {
+ pages[pageNum] = fileInfo;
+ }
+ }
+
+ // Download the file
+ var downloadRequest = new DownloadFileRequest(fileInfo.Url);
+ var response = fileApi.DownloadFile(downloadRequest);
+
+ // Save to local file
+ string outputPath = Path.Combine(downloadFolder, fileInfo.Name);
+ using (var fileStream = File.Create(outputPath))
+ {
+ response.CopyTo(fileStream);
+ }
+
+ Console.WriteLine($"Downloaded to {outputPath}");
+}
+
+// Process pages in order
+foreach (var pageNum in pages.Keys.OrderBy(k => k))
+{
+ var pageFile = pages[pageNum];
+ Console.WriteLine($"Processing page {pageNum}: {pageFile.Name}");
+ // Add your page processing logic here...
+}
+```
+
+### Java Example
+
+```java
+// Tutorial Code Example: Complete ConversionResult Processing in Java
+import com.groupdocs.conversion.cloud.api.ConvertApi;
+import com.groupdocs.conversion.cloud.api.FileApi;
+import com.groupdocs.conversion.cloud.api.model.*;
+import com.groupdocs.conversion.cloud.api.model.requests.*;
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.stream.Collectors;
+
+// Configure the API client
+Configuration configuration = new Configuration();
+configuration.setClientId("YOUR_CLIENT_ID");
+configuration.setClientSecret("YOUR_CLIENT_SECRET");
+
+ConvertApi convertApi = new ConvertApi(configuration);
+FileApi fileApi = new FileApi(configuration);
+
+// Create conversion settings
+ConvertSettings settings = new ConvertSettings();
+settings.setFilePath("documents/multipage.docx");
+settings.setFormat("jpeg");
+settings.setOutputPath("converted/");
+
+try {
+ // Execute conversion
+ List result = convertApi.convert(new ConvertRequest(settings));
+ System.out.println("Conversion completed: " + result.size() + " files generated");
+
+ // Process and download results
+ String downloadFolder = "downloads";
+ Files.createDirectories(Paths.get(downloadFolder));
+
+ // Organize results by page
+ Map pages = new HashMap<>();
+ for (StoredConvertedResult fileInfo : result) {
+ System.out.println("File: " + fileInfo.getName() +
+ ", Size: " + fileInfo.getSize() + " bytes, URL: " + fileInfo.getUrl());
+
+ // Extract page number from filename
+ if (fileInfo.getName().contains("-page-")) {
+ String[] parts = fileInfo.getName().split("-page-");
+ String pageNumStr = parts[1].split("\\.")[0];
+ try {
+ int pageNum = Integer.parseInt(pageNumStr);
+ pages.put(pageNum, fileInfo);
+ } catch (NumberFormatException e) {
+ System.out.println("Could not parse page number: " + pageNumStr);
+ }
+ }
+
+ // Download the file
+ DownloadFileRequest downloadRequest = new DownloadFileRequest(fileInfo.getUrl());
+ byte[] response = fileApi.downloadFile(downloadRequest);
+
+ // Save to local file
+ String outputPath = Paths.get(downloadFolder, fileInfo.getName()).toString();
+ Files.write(Paths.get(outputPath), response);
+
+ System.out.println("Downloaded to " + outputPath);
+ }
+
+ // Process pages in order
+ List sortedPageNums = pages.keySet().stream().sorted().collect(Collectors.toList());
+ for (Integer pageNum : sortedPageNums) {
+ StoredConvertedResult pageFile = pages.get(pageNum);
+ System.out.println("Processing page " + pageNum + ": " + pageFile.getName());
+ // Add your page processing logic here...
+ }
+
+} catch (Exception e) {
+ System.out.println("Error: " + e.getMessage());
+ e.printStackTrace();
+}
+```
+
+## Tips and Best Practices
+
+### 1. Optimize Cloud Storage Management
+
+Manage your cloud storage efficiently:
+- Delete temporary conversion files once downloaded and processed
+- Organize converted files in a structured folder hierarchy
+- Set up automated cleanup for old converted files
+- Monitor storage usage to avoid quota limits
+
+```python
+# Tutorial Code Example: Cleaning Up Temporary Files
+def cleanup_converted_files(result, storage_api):
+ """Delete converted files from cloud storage after processing"""
+ for file in result:
+ try:
+ request = DeleteFileRequest(file["url"])
+ storage_api.delete_file(request)
+ print(f"Deleted {file['name']} from cloud storage")
+ except Exception as e:
+ print(f"Error deleting {file['name']}: {e}")
+```
+
+### 2. Implement Reliable Error Handling
+
+Always implement proper error handling for API operations:
+- Check for API connection errors
+- Verify file existence before downloading
+- Implement retries for transient errors
+- Log detailed error information for troubleshooting
+
+### 3. Use Batch Processing for Large Documents
+
+For large documents with many pages:
+- Process pages in batches to manage memory efficiently
+- Implement progress tracking for long-running conversions
+- Consider parallel processing for faster operations
+
+### 4. Track Conversion Metadata
+
+Maintain metadata about your conversions:
+- Record document names, page counts, and file sizes
+- Track conversion timestamps for auditing
+- Store relationships between original and converted files
+
+## Troubleshooting Common Issues
+
+### Issue 1: Missing Files in ConversionResult
+If files are missing from your ConversionResult:
+- Verify the document exists and is accessible
+- Check if page selection options limited the conversion
+- Ensure the document has content (not blank or corrupted)
+
+### Issue 2: Access Denied When Downloading
+If you receive access denied errors:
+- Verify your access token is valid and not expired
+- Check permissions for the storage and files
+- Ensure the file paths are correctly formatted
+
+### Issue 3: File Size Discrepancies
+If downloaded file sizes don't match expected sizes:
+- Ensure you're reading the file in binary mode
+- Check for network interruptions during download
+- Verify no content encoding/compression is applied
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- The structure and purpose of ConversionResult in the GroupDocs.Conversion Cloud API
+- How to process and download converted files
+- Techniques for organizing and managing multi-page conversions
+- Best practices for working with converted documents in cloud storage
+- Implementation examples in multiple programming languages
+
+## Further Practice
+
+To reinforce your understanding:
+1. Create a utility that downloads and organizes converted files by document type and date
+2. Implement a system that tracks conversion statistics (file sizes, page counts, etc.)
+3. Build a simple web interface to view and download converted documents
+4. Create a batch processor for converting and organizing large document collections
+
+## Next Steps
+
+Ready to advance your skills? Move on to our next tutorial: [Tutorial: Implementing Format-Specific Conversion Options](/data-organization/format-specific-options/) to learn more about optimizing conversions for particular document formats.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about working with ConversionResult? Need clarification on any part of this tutorial? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
\ No newline at end of file
diff --git a/content/conversion/english/data-organization/conversion-settings/_index.md b/content/conversion/english/data-organization/conversion-settings/_index.md
new file mode 100644
index 0000000..0e57124
--- /dev/null
+++ b/content/conversion/english/data-organization/conversion-settings/_index.md
@@ -0,0 +1,438 @@
+---
+title: How to Work with Conversion Settings in GroupDocs.Conversion Cloud API Tutorial
+weight: 10
+url: /data-organization/conversion-settings/
+description: Learn how to configure and apply conversion settings in GroupDocs.Conversion Cloud API with this step-by-step tutorial for developers
+---
+
+# Tutorial: How to Work with Conversion Settings in GroupDocs.Conversion Cloud API
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- What ConversionSettings are and their role in document conversion
+- How to structure conversion settings for different scenarios
+- Best practices for configuring document conversion parameters
+- Techniques for troubleshooting common settings issues
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with JSON data structures
+- A development environment set up for your preferred language (examples provided in cURL, Python, Java, and C#)
+
+## What are ConversionSettings?
+
+ConversionSettings are critical data structures that control how the GroupDocs.Conversion Cloud API processes your documents. They define:
+
+- The source document to convert
+- The target format for conversion
+- How to load the document (LoadOptions)
+- Format-specific conversion parameters (ConvertOptions)
+- Where to store the conversion results
+
+Think of ConversionSettings as a comprehensive instruction set for the API to follow when converting your documents.
+
+## Understanding the ConversionSettings Structure
+
+Let's examine the basic structure of ConversionSettings:
+
+```json
+{
+ "Format": "string",
+ "FilePath": "string",
+ "Storage": "string",
+ "LoadOptions": {
+ "Password": "string"
+ },
+ "ConvertOptions": {
+ "FromPage": "integer",
+ "PagesCount": "integer"
+ },
+ "OutputPath": "string"
+}
+```
+
+Each field serves a specific purpose:
+
+| Field | Description | Required? |
+|-------|-------------|-----------|
+| Format | Target conversion format (e.g., "pdf", "docx") | Yes |
+| FilePath | Path to the source document in storage | Yes |
+| Storage | Storage name where document is located | No |
+| LoadOptions | Format-specific options for loading the document | No |
+| ConvertOptions | Format-specific options for the conversion process | No |
+| OutputPath | Path where conversion results will be stored | No |
+
+## Step 1: Creating Basic ConversionSettings
+
+Let's start with a simple example of converting a Word document to PDF:
+
+```python
+# Tutorial Code Example: Basic Conversion Settings
+conversion_settings = {
+ "Format": "pdf", # Target format is PDF
+ "FilePath": "documents/sample.docx", # Source document path
+ "OutputPath": "converted/" # Where to save the result
+}
+
+# This minimal setup instructs the API to:
+# 1. Find a file named "sample.docx" in the "documents" folder
+# 2. Convert it to PDF format
+# 3. Save the result in the "converted" folder
+```
+
+### Try it yourself
+
+Create conversion settings for converting an Excel file to HTML:
+
+```python
+# Exercise: Create ConversionSettings for Excel to HTML conversion
+# Your code here:
+conversion_settings = {
+ "Format": "html",
+ "FilePath": "spreadsheets/data.xlsx",
+ "OutputPath": "converted/web/"
+}
+```
+
+## Step 2: Adding LoadOptions for Protected Documents
+
+Many documents are password-protected. Let's see how to handle this:
+
+```python
+# Tutorial Code Example: Conversion Settings with LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/protected.docx",
+ "LoadOptions": {
+ "Password": "your-password-here" # Password to open the document
+ },
+ "OutputPath": "converted/"
+}
+
+# Now the API will:
+# 1. Use the provided password to open the protected document
+# 2. Proceed with conversion as instructed
+```
+
+Different document formats support different LoadOptions. For example, spreadsheet documents have additional options:
+
+```python
+# Tutorial Code Example: Excel-specific LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "spreadsheets/quarterly_report.xlsx",
+ "LoadOptions": {
+ "Password": "your-password-here",
+ "ShowGridLines": True,
+ "OnePagePerSheet": True,
+ "SkipEmptyRowsAndColumns": True
+ },
+ "OutputPath": "converted/"
+}
+```
+
+### Try it yourself
+
+Create conversion settings for a password-protected PowerPoint file with specific loading options:
+
+```python
+# Exercise: Create ConversionSettings with LoadOptions for PowerPoint
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "presentations/company_deck.pptx",
+ "LoadOptions": {
+ "Password": "secure123",
+ "ShowHiddenSlides": False
+ },
+ "OutputPath": "converted/presentations/"
+}
+```
+
+## Step 3: Customizing Conversion with ConvertOptions
+
+ConvertOptions allow you to fine-tune how the conversion process works:
+
+```python
+# Tutorial Code Example: Conversion Settings with ConvertOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/large_report.docx",
+ "ConvertOptions": {
+ "FromPage": 5, # Start conversion from page 5
+ "PagesCount": 10, # Convert only 10 pages
+ "Zoom": 100, # Zoom level for the output
+ "Grayscale": True # Convert to grayscale PDF
+ },
+ "OutputPath": "converted/"
+}
+
+# This configuration tells the API to:
+# 1. Convert only pages 5-14 of the document
+# 2. Use 100% zoom level
+# 3. Create a grayscale PDF instead of color
+```
+
+Different target formats support different ConvertOptions. For image conversions, you might specify:
+
+```python
+# Tutorial Code Example: Image-specific ConvertOptions
+conversion_settings = {
+ "Format": "jpeg",
+ "FilePath": "documents/brochure.pdf",
+ "ConvertOptions": {
+ "Width": 1920,
+ "Height": 1080,
+ "Quality": 95,
+ "RotateAngle": 0
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+### Try it yourself
+
+Create conversion settings for converting specific pages of a PDF to PNG images with custom dimensions:
+
+```python
+# Exercise: Create ConversionSettings with ConvertOptions for PDF to PNG
+# Your code here:
+conversion_settings = {
+ "Format": "png",
+ "FilePath": "documents/annual_report.pdf",
+ "ConvertOptions": {
+ "Width": 800,
+ "Height": 600,
+ "FromPage": 10,
+ "PagesCount": 5
+ },
+ "OutputPath": "converted/report_images/"
+}
+```
+
+## Step 4: Putting It All Together
+
+Now, let's create a complete example with all components:
+
+```python
+# Tutorial Code Example: Complete ConversionSettings
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/quarterly_report.xlsx",
+ "Storage": "WorkDocuments",
+ "LoadOptions": {
+ "Password": "report2023",
+ "ShowGridLines": False,
+ "ShowHiddenSheets": False
+ },
+ "ConvertOptions": {
+ "FromPage": 1,
+ "PagesCount": 5,
+ "Zoom": 100,
+ "Grayscale": False,
+ "MarginTop": 0.5,
+ "MarginBottom": 0.5,
+ "MarginLeft": 0.5,
+ "MarginRight": 0.5
+ },
+ "OutputPath": "converted/reports/q3_2023/"
+}
+```
+
+## Implementation Examples
+
+Let's see how to use ConversionSettings with the API:
+
+### cURL Example
+
+```bash
+# Tutorial Code Example: Using ConversionSettings with cURL
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "Format": "pdf",
+ "FilePath": "documents/sample.docx",
+ "LoadOptions": {
+ "Password": "docx-password"
+ },
+ "ConvertOptions": {
+ "FromPage": 1,
+ "PagesCount": 10
+ },
+ "OutputPath": "converted/"
+ }'
+```
+
+### Python Example
+
+```python
+# Tutorial Code Example: Using ConversionSettings with Python SDK
+import groupdocs_conversion_cloud
+
+# Configure the API client
+configuration = groupdocs_conversion_cloud.Configuration(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET"
+)
+api_client = groupdocs_conversion_cloud.ApiClient(configuration)
+api = groupdocs_conversion_cloud.ConvertApi(api_client)
+
+# Create conversion settings
+settings = groupdocs_conversion_cloud.ConvertSettings()
+settings.file_path = "documents/sample.docx"
+settings.format = "pdf"
+
+# Add load options if needed
+load_options = groupdocs_conversion_cloud.DocxLoadOptions()
+load_options.password = "docx-password"
+settings.load_options = load_options
+
+# Add convert options if needed
+convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+convert_options.from_page = 1
+convert_options.pages_count = 10
+settings.convert_options = convert_options
+
+settings.output_path = "converted/"
+
+# Execute conversion
+result = api.convert(settings)
+print(f"Document converted successfully! Results: {result}")
+```
+
+### C# Example
+
+```csharp
+// Tutorial Code Example: Using ConversionSettings with C# SDK
+using GroupDocs.Conversion.Cloud.Sdk;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Configure the API client
+var configuration = new Configuration
+{
+ ClientId = "YOUR_CLIENT_ID",
+ ClientSecret = "YOUR_CLIENT_SECRET"
+};
+var apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+var settings = new ConvertSettings
+{
+ FilePath = "documents/sample.docx",
+ Format = "pdf",
+ LoadOptions = new DocxLoadOptions
+ {
+ Password = "docx-password"
+ },
+ ConvertOptions = new PdfConvertOptions
+ {
+ FromPage = 1,
+ PagesCount = 10
+ },
+ OutputPath = "converted/"
+};
+
+// Execute conversion
+var result = apiInstance.Convert(new ConvertRequest(settings));
+Console.WriteLine($"Document converted successfully! Results: {result.Count} files");
+```
+
+### Java Example
+
+```java
+// Tutorial Code Example: Using ConversionSettings with Java SDK
+import com.groupdocs.conversion.cloud.api.ConvertApi;
+import com.groupdocs.conversion.cloud.api.model.*;
+import com.groupdocs.conversion.cloud.api.model.requests.ConvertRequest;
+
+// Configure the API client
+Configuration configuration = new Configuration();
+configuration.setClientId("YOUR_CLIENT_ID");
+configuration.setClientSecret("YOUR_CLIENT_SECRET");
+ConvertApi apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+ConvertSettings settings = new ConvertSettings();
+settings.setFilePath("documents/sample.docx");
+settings.setFormat("pdf");
+
+// Add load options if needed
+DocxLoadOptions loadOptions = new DocxLoadOptions();
+loadOptions.setPassword("docx-password");
+settings.setLoadOptions(loadOptions);
+
+// Add convert options if needed
+PdfConvertOptions convertOptions = new PdfConvertOptions();
+convertOptions.setFromPage(1);
+convertOptions.setPagesCount(10);
+settings.setConvertOptions(convertOptions);
+
+settings.setOutputPath("converted/");
+
+// Execute conversion
+List result = apiInstance.convert(new ConvertRequest(settings));
+System.out.println("Document converted successfully! Results: " + result.size() + " files");
+```
+
+## Troubleshooting Common Issues
+
+### Issue 1: File Not Found Errors
+If you encounter "File not found" errors, ensure:
+- The FilePath is correct and the file exists in your storage
+- You have the correct Storage name if using a non-default storage
+- The file path follows the correct format (e.g., "folder/file.ext")
+
+### Issue 2: Conversion Fails with Protected Documents
+If conversion fails with password-protected documents:
+- Verify the password is correct
+- Ensure you're using the right type of LoadOptions for your document format
+- Check that the password is provided as a string
+
+### Issue 3: Unexpected Conversion Results
+If the conversion output is not as expected:
+- Review the ConvertOptions to ensure they're appropriate for your target format
+- Check format-specific documentation for special requirements
+- Try converting without ConvertOptions first, then add them incrementally
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- The structure and purpose of ConversionSettings in the GroupDocs.Conversion Cloud API
+- How to configure basic conversion parameters
+- Techniques for handling protected documents with LoadOptions
+- Methods for customizing conversion output with ConvertOptions
+- Practical implementation in multiple programming languages
+- Troubleshooting common conversion issues
+
+## Further Practice
+
+To reinforce your understanding:
+1. Try converting different document types (PDF, Excel, PowerPoint) with custom settings
+2. Experiment with different target formats and observe how ConvertOptions affect the output
+3. Create a simple application that allows users to specify their own conversion settings
+4. Implement error handling for common conversion issues
+
+## Next Steps
+
+Ready to advance your skills? Move on to our next tutorial: [Tutorial: Understanding Load Options in Document Conversion](/data-organization/load-options/) to learn more about optimizing the document loading process for different formats.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about working with ConversionSettings? Need clarification on any part of this tutorial? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
diff --git a/content/conversion/english/data-organization/convert-options/_index.md b/content/conversion/english/data-organization/convert-options/_index.md
new file mode 100644
index 0000000..2b10a85
--- /dev/null
+++ b/content/conversion/english/data-organization/convert-options/_index.md
@@ -0,0 +1,588 @@
+---
+title: Working with Convert Options Tutorial
+weight: 30
+url: /data-organization/convert-options/
+description: Learn how to configure format-specific conversion parameters for precise output control with this hands-on tutorial for GroupDocs.Conversion Cloud API
+---
+
+# Tutorial: Working with Convert Options
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- What ConvertOptions are and their role in controlling conversion output
+- How to configure format-specific conversion parameters
+- Techniques for optimizing conversion quality for different target formats
+- Best practices for advanced conversion scenarios
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with JSON data structures
+- Completion of the [LoadOptions tutorial](/data-organization/load-options) (recommended)
+- A development environment set up for your preferred language (examples provided in cURL, Python, Java, and C#)
+
+## What are ConvertOptions?
+
+ConvertOptions control how GroupDocs.Conversion Cloud API generates output files during the conversion process. While LoadOptions focus on reading the input document, ConvertOptions determine how the output document is created and formatted.
+
+Different target formats support different conversion options. Using the right ConvertOptions ensures your converted documents meet your specific requirements for quality, appearance, and functionality.
+
+## Why ConvertOptions Matter
+
+Consider these scenarios where ConvertOptions make a significant difference:
+
+1. Image quality control: When converting to image formats, options like width, height, and quality are essential
+2. Page selection: Convert only specific pages from multi-page documents
+3. PDF optimization: Control PDF version, compression, and security settings
+4. Document appearance: Adjust margins, zoom levels, and other visual aspects
+5. Watermarking: Add text or image watermarks during conversion
+
+Let's explore how to implement ConvertOptions for different target formats.
+
+## Step 1: Understanding Common ConvertOptions Properties
+
+Some ConvertOptions properties are available across multiple target formats:
+
+### Page Selection
+
+Most formats support selecting specific pages for conversion:
+
+```python
+# Tutorial Code Example: Page Selection ConvertOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/large_report.docx",
+ "ConvertOptions": {
+ "FromPage": 5, # Start conversion from page 5
+ "PagesCount": 10, # Convert only 10 pages
+ "Pages": [2, 4, 6] # OR specify exact pages to convert (takes precedence)
+ },
+ "OutputPath": "converted/"
+}
+```
+
+The page selection options work as follows:
+- `FromPage`: The starting page number (1-based index)
+- `PagesCount`: The number of pages to convert starting from `FromPage`
+- `Pages`: An array of specific page numbers to convert (if provided, overrides `FromPage` and `PagesCount`)
+
+### Using PDF as Intermediate Format
+
+Many formats support conversion through an intermediate PDF format:
+
+```python
+# Tutorial Code Example: Using PDF as Intermediate Format
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "presentations/quarterly_update.pptx",
+ "ConvertOptions": {
+ "UsePdf": True # Use PDF as intermediate conversion format
+ },
+ "OutputPath": "converted/"
+}
+```
+
+Using PDF as an intermediate format can improve conversion quality in some scenarios, particularly when converting between very different format types.
+
+### Watermarking
+
+Most output formats support adding watermarks during conversion:
+
+```python
+# Tutorial Code Example: Adding Watermarks
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/contract.docx",
+ "ConvertOptions": {
+ "WatermarkOptions": {
+ "Text": "CONFIDENTIAL",
+ "Font": "Arial",
+ "Color": "red",
+ "Width": 500,
+ "Height": 100,
+ "Top": 400,
+ "Left": 200,
+ "RotationAngle": 45,
+ "Transparency": 0.5,
+ "Background": True, # Place watermark in background
+ "Image": None # Use text watermark (could use image instead)
+ }
+ },
+ "OutputPath": "converted/"
+}
+```
+
+### Try it yourself
+
+Create ConvertOptions for a PowerPoint file where you want to convert only slides 2-5 and add a "DRAFT" watermark:
+
+```python
+# Exercise: Create ConvertOptions with page selection and watermark
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "presentations/product_launch.pptx",
+ "ConvertOptions": {
+ "FromPage": 2,
+ "PagesCount": 4,
+ "WatermarkOptions": {
+ "Text": "DRAFT",
+ "Font": "Calibri",
+ "Color": "blue",
+ "Width": 400,
+ "Height": 80,
+ "RotationAngle": 30,
+ "Transparency": 0.7
+ }
+ },
+ "OutputPath": "converted/drafts/"
+}
+```
+
+## Step 2: Format-Specific ConvertOptions
+
+Let's explore ConvertOptions for specific target formats:
+
+### Image Conversion Options (PNG, JPG, TIFF, etc.)
+
+When converting to image formats, you can control dimensions, resolution, and other visual properties:
+
+```python
+# Tutorial Code Example: Image ConvertOptions
+conversion_settings = {
+ "Format": "jpeg",
+ "FilePath": "documents/brochure.pdf",
+ "ConvertOptions": {
+ "Width": 1920, # Image width in pixels
+ "Height": 1080, # Image height in pixels
+ "HorizontalResolution": 96, # Horizontal DPI
+ "VerticalResolution": 96, # Vertical DPI
+ "Quality": 95, # JPEG quality (1-100)
+ "Grayscale": False, # Convert to grayscale
+ "RotateAngle": 0, # Rotation angle in degrees
+ "BackgroundColor": "white" # Background color
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+Different image formats support additional specific options:
+
+#### TIFF-Specific Options
+
+```python
+# Tutorial Code Example: TIFF-Specific ConvertOptions
+conversion_settings = {
+ "Format": "tiff",
+ "FilePath": "documents/manual.pdf",
+ "ConvertOptions": {
+ "Width": 1240,
+ "Height": 1754,
+ "HorizontalResolution": 150,
+ "VerticalResolution": 150,
+ "Compression": "lzw", # TIFF compression method (lzw, ccitt4, etc.)
+ "Grayscale": True
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+#### WebP-Specific Options
+
+```python
+# Tutorial Code Example: WebP-Specific ConvertOptions
+conversion_settings = {
+ "Format": "webp",
+ "FilePath": "images/diagram.png",
+ "ConvertOptions": {
+ "Width": 800,
+ "Height": 600,
+ "Lossless": True, # Use lossless compression
+ "Grayscale": False
+ },
+ "OutputPath": "converted/web_images/"
+}
+```
+
+### PDF Conversion Options
+
+When converting to PDF, you have extensive control over the output document:
+
+```python
+# Tutorial Code Example: PDF ConvertOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/report.docx",
+ "ConvertOptions": {
+ "Width": 612, # Page width in points
+ "Height": 792, # Page height in points
+ "Dpi": 300, # Document DPI
+ "Password": "secure-pdf", # Set password on output PDF
+ "MarginTop": 0.5, # Top margin in inches
+ "MarginBottom": 0.5, # Bottom margin in inches
+ "MarginLeft": 0.5, # Left margin in inches
+ "MarginRight": 0.5, # Right margin in inches
+ "PdfFormat": "v1.7", # PDF format version
+ "RemovePdfACompliance": False, # Keep PDF/A compliance
+ "Zoom": 100, # Zoom level (percentage)
+ "Linearize": True, # Optimize for web viewing
+ "LinkDuplicateStreams": True, # Optimize duplicate content
+ "RemoveUnusedObjects": True, # Remove unused objects
+ "RemoveUnusedStreams": True, # Remove unused streams
+ "CompressImages": True, # Compress images
+ "ImageQuality": 95, # Image quality after compression
+ "UnembedFonts": False, # Keep embedded fonts
+ "Grayscale": False, # Convert to grayscale
+ },
+ "OutputPath": "converted/pdfs/"
+}
+```
+
+### Word Processing Conversion Options (DOCX, RTF, etc.)
+
+When converting to Word formats, you can control page setup and other options:
+
+```python
+# Tutorial Code Example: Word Processing ConvertOptions
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "documents/article.pdf",
+ "ConvertOptions": {
+ "Width": 8.5, # Page width in inches
+ "Height": 11, # Page height in inches
+ "Dpi": 300, # Document DPI
+ "Password": "", # Set password on output document
+ "Zoom": 100, # Zoom level
+ "PdfRecognitionMode": "Textbox", # Mode for PDF conversion (Textbox or Flow)
+ "PageSize": "Letter", # Page size (Letter, A4, etc.)
+ "PageOrientation": "Portrait" # Page orientation
+ },
+ "OutputPath": "converted/word/"
+}
+```
+
+### Spreadsheet Conversion Options (XLSX, CSV, etc.)
+
+When converting to spreadsheet formats, options are more limited but still important:
+
+```python
+# Tutorial Code Example: Spreadsheet ConvertOptions
+conversion_settings = {
+ "Format": "xlsx",
+ "FilePath": "documents/data_table.pdf",
+ "ConvertOptions": {
+ "Password": "", # Set password on output spreadsheet
+ "Zoom": 100 # Zoom level
+ },
+ "OutputPath": "converted/excel/"
+}
+```
+
+### Try it yourself
+
+Create ConvertOptions for converting a Word document to a high-quality PDF with specific page dimensions and security settings:
+
+```python
+# Exercise: Create PDF ConvertOptions with security settings
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/confidential_report.docx",
+ "ConvertOptions": {
+ "Width": 8.5,
+ "Height": 11,
+ "Dpi": 300,
+ "Password": "secure-pdf-2023",
+ "MarginTop": 0.75,
+ "MarginBottom": 0.75,
+ "MarginLeft": 1.0,
+ "MarginRight": 1.0,
+ "PdfFormat": "v1.7",
+ "CompressImages": True,
+ "ImageQuality": 90,
+ "Linearize": True,
+ "RemoveUnusedObjects": True
+ },
+ "OutputPath": "converted/secure_pdfs/"
+}
+```
+
+## Step 3: Advanced ConvertOptions Scenarios
+
+### Format-Specific Conversion Paths
+
+Some conversions perform better with specific options or intermediate formats:
+
+```python
+# Tutorial Code Example: Optimized Conversion Path
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "diagrams/flowchart.svg",
+ "ConvertOptions": {
+ "UsePdf": True, # Use PDF as intermediate format
+ "Width": 1200,
+ "Height": 900,
+ "Grayscale": False
+ },
+ "OutputPath": "converted/diagrams/"
+}
+```
+
+### E-book Conversion Options (EPUB)
+
+When converting to EPUB, you have specific options for e-book formatting:
+
+```python
+# Tutorial Code Example: EPUB ConvertOptions
+conversion_settings = {
+ "Format": "epub",
+ "FilePath": "documents/manuscript.docx",
+ "ConvertOptions": {
+ "PageSize": "A5",
+ "PageOrientation": "Portrait",
+ "WatermarkOptions": {
+ "Text": "Sample",
+ "Font": "Times New Roman",
+ "Color": "gray",
+ "Transparency": 0.7
+ }
+ },
+ "OutputPath": "converted/ebooks/"
+}
+```
+
+## Implementation Examples
+
+Let's see how to implement ConvertOptions with the API:
+
+### cURL Example
+
+```bash
+# Tutorial Code Example: Using ConvertOptions with cURL
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "Format": "jpeg",
+ "FilePath": "documents/diagram.pdf",
+ "ConvertOptions": {
+ "Width": 1920,
+ "Height": 1080,
+ "Quality": 95,
+ "FromPage": 1,
+ "PagesCount": 3
+ },
+ "OutputPath": "converted/"
+ }'
+```
+
+### Python Example
+
+```python
+# Tutorial Code Example: Using ConvertOptions with Python SDK
+import groupdocs_conversion_cloud
+
+# Configure the API client
+configuration = groupdocs_conversion_cloud.Configuration(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET"
+)
+api_client = groupdocs_conversion_cloud.ApiClient(configuration)
+api = groupdocs_conversion_cloud.ConvertApi(api_client)
+
+# Create conversion settings
+settings = groupdocs_conversion_cloud.ConvertSettings()
+settings.file_path = "documents/diagram.pdf"
+settings.format = "jpeg"
+
+# Configure JPEG-specific convert options
+convert_options = groupdocs_conversion_cloud.JpegConvertOptions()
+convert_options.width = 1920
+convert_options.height = 1080
+convert_options.quality = 95
+convert_options.from_page = 1
+convert_options.pages_count = 3
+settings.convert_options = convert_options
+
+settings.output_path = "converted/"
+
+# Execute conversion
+result = api.convert(settings)
+print(f"Document converted successfully! Results: {result}")
+```
+
+### C# Example
+
+```csharp
+// Tutorial Code Example: Using ConvertOptions with C# SDK
+using GroupDocs.Conversion.Cloud.Sdk;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Configure the API client
+var configuration = new Configuration
+{
+ ClientId = "YOUR_CLIENT_ID",
+ ClientSecret = "YOUR_CLIENT_SECRET"
+};
+var apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+var settings = new ConvertSettings
+{
+ FilePath = "documents/diagram.pdf",
+ Format = "jpeg",
+ ConvertOptions = new JpegConvertOptions
+ {
+ Width = 1920,
+ Height = 1080,
+ Quality = 95,
+ FromPage = 1,
+ PagesCount = 3
+ },
+ OutputPath = "converted/"
+};
+
+// Execute conversion
+var result = apiInstance.Convert(new ConvertRequest(settings));
+Console.WriteLine($"Document converted successfully! Results: {result.Count} files");
+```
+
+### Java Example
+
+```java
+// Tutorial Code Example: Using ConvertOptions with Java SDK
+import com.groupdocs.conversion.cloud.api.ConvertApi;
+import com.groupdocs.conversion.cloud.api.model.*;
+import com.groupdocs.conversion.cloud.api.model.requests.ConvertRequest;
+
+// Configure the API client
+Configuration configuration = new Configuration();
+configuration.setClientId("YOUR_CLIENT_ID");
+configuration.setClientSecret("YOUR_CLIENT_SECRET");
+ConvertApi apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+ConvertSettings settings = new ConvertSettings();
+settings.setFilePath("documents/diagram.pdf");
+settings.setFormat("jpeg");
+
+// Configure JPEG-specific convert options
+JpegConvertOptions convertOptions = new JpegConvertOptions();
+convertOptions.setWidth(1920);
+convertOptions.setHeight(1080);
+convertOptions.setQuality(95);
+convertOptions.setFromPage(1);
+convertOptions.setPagesCount(3);
+settings.setConvertOptions(convertOptions);
+
+settings.setOutputPath("converted/");
+
+// Execute conversion
+List result = apiInstance.convert(new ConvertRequest(settings));
+System.out.println("Document converted successfully! Results: " + result.size() + " files");
+```
+
+## Tips and Best Practices
+
+### 1. Match ConvertOptions to Target Format
+
+Always use the correct ConvertOptions type for your target format:
+- Use `JpegConvertOptions` for JPEG output
+- Use `PdfConvertOptions` for PDF output
+- Use `WordProcessingConvertOptions` for DOCX, DOC, and other word formats
+
+Using mismatched ConvertOptions types will result in errors or unexpected behavior.
+
+### 2. Optimize for Specific Use Cases
+
+Tailor your conversion options based on your specific needs:
+- For high-quality printing: Use higher DPI, resolution, and quality settings
+- For web viewing: Optimize file size and use web-friendly formats
+- For editable documents: Focus on content structure preservation
+
+### 3. Balance Quality and Size
+
+Higher quality typically means larger file sizes:
+- For images, the `Quality` parameter directly affects file size
+- For PDFs, options like `CompressImages` and `ImageQuality` help balance quality and size
+- Consider your audience's needs and bandwidth constraints
+
+### 4. Use Page Selection Strategically
+
+Page selection can improve efficiency:
+- Convert only the pages you need instead of entire documents
+- For large documents, consider converting in batches
+- The `Pages` array lets you select non-sequential pages
+
+### 5. Test Different Options
+
+Conversion quality can vary based on document complexity:
+- Test multiple option combinations for optimal results
+- Consider using `UsePdf` for complex format conversions
+- Compare different conversion paths for the same document
+
+## Troubleshooting Common Issues
+
+### Issue 1: Unexpected Image Dimensions
+If images don't have the expected dimensions:
+- Remember that some format conversions maintain aspect ratio
+- Set both `Width` and `Height` for precise control
+- Check if the input document has special page sizes
+
+### Issue 2: Poor Image Quality
+If image quality is lower than expected:
+- Increase the `Quality` parameter for lossy formats like JPEG
+- Use higher `HorizontalResolution` and `VerticalResolution` values
+- For PDF to image conversions, set higher DPI values
+
+### Issue 3: Missing Pages
+If pages are missing from your conversion:
+- Verify `FromPage` and `PagesCount` values are correct
+- Remember that page counting starts at 1, not 0
+- Check if you've inadvertently set a restrictive page range
+
+### Issue 4: Password Protection Problems
+If password protection doesn't work:
+- Ensure the target format supports password protection
+- Check if special characters in passwords are properly encoded
+- Verify minimum password length requirements for the format
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- The purpose and importance of ConvertOptions in document conversion
+- How to configure format-specific conversion parameters
+- Techniques for optimizing conversion quality for different target formats
+- Best practices for advanced conversion scenarios
+- Implementation examples in multiple programming languages
+
+## Further Practice
+
+To reinforce your understanding:
+1. Try converting the same document to different formats with various ConvertOptions
+2. Experiment with image conversion settings to balance quality and file size
+3. Create a simple application that allows users to specify custom ConvertOptions
+4. Test watermarking options with different text, placement, and transparency settings
+
+## Next Steps
+
+Ready to expand your knowledge? Continue to our next tutorial: [Tutorial: Processing Conversion Results](/data-organization/conversion-result/) to learn how to efficiently handle and organize conversion output.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about working with ConvertOptions? Need clarification on any part of this tutorial? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
\ No newline at end of file
diff --git a/content/conversion/english/data-organization/format-specific-options/_index.md b/content/conversion/english/data-organization/format-specific-options/_index.md
new file mode 100644
index 0000000..0f7b190
--- /dev/null
+++ b/content/conversion/english/data-organization/format-specific-options/_index.md
@@ -0,0 +1,799 @@
+---
+title: Implementing Format-Specific Conversion Options Tutorial
+weight: 50
+url: /data-organization/format-specific-options/
+description: Learn how to optimize conversion settings for particular document formats with this comprehensive tutorial for GroupDocs.Conversion Cloud API
+---
+
+# Tutorial: Implementing Format-Specific Conversion Options
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- How to configure format-specific conversion options for optimal results
+- Advanced techniques for optimizing image, PDF, Office and other document formats
+- Best practices for selecting the right conversion options by format
+- How to troubleshoot format-specific conversion issues
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with JSON data structures
+- Completion of the previous tutorials in this series (recommended)
+- A development environment set up for your preferred language (examples provided in cURL, Python, Java, and C#)
+
+## Why Format-Specific Options Matter
+
+Different document formats have unique characteristics and conversion requirements. Using generic conversion settings often produces sub-optimal results, while format-specific options allow you to:
+
+1. Preserve format-specific features and content
+2. Control quality and appearance with precision
+3. Optimize file size for specific use cases
+4. Enable format-specific security and compatibility features
+
+In this tutorial, we'll explore the most important format-specific options for common document types and show you how to implement them effectively.
+
+## Step 1: Image Format Conversion Options
+
+Let's start with options for various image formats:
+
+### JPEG Conversion Options
+
+JPEG is ideal for photographs and complex images with gradients:
+
+```python
+# Tutorial Code Example: JPEG-Specific Conversion Options
+conversion_settings = {
+ "Format": "jpeg",
+ "FilePath": "documents/report.pdf",
+ "ConvertOptions": {
+ "Width": 1920, # Image width in pixels
+ "Height": 1080, # Image height in pixels
+ "HorizontalResolution": 300, # Horizontal DPI
+ "VerticalResolution": 300, # Vertical DPI
+ "Quality": 90, # JPEG quality (1-100) - critical for JPEG
+ "Grayscale": False, # Keep color information
+ "RotateAngle": 0, # No rotation
+ "BackgroundColor": "white" # White background for transparent areas
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+Key JPEG-specific considerations:
+- Quality: Most important setting for JPEG; higher values increase quality but also file size
+- Resolution: 72-96 DPI for web, 150-300 DPI for printing
+- Color mode: Use grayscale for black and white documents to reduce file size
+
+### PNG Conversion Options
+
+PNG is best for graphics, diagrams, and images with transparency:
+
+```python
+# Tutorial Code Example: PNG-Specific Conversion Options
+conversion_settings = {
+ "Format": "png",
+ "FilePath": "documents/logo.psd",
+ "ConvertOptions": {
+ "Width": 800, # Image width in pixels
+ "Height": 600, # Image height in pixels
+ "HorizontalResolution": 96, # Web-optimized resolution
+ "VerticalResolution": 96, # Web-optimized resolution
+ "Grayscale": False, # Keep color information
+ "RotateAngle": 0, # No rotation
+ "BackgroundColor": "transparent" # PNG supports transparency
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+Key PNG-specific considerations:
+- Transparency: PNG supports transparent backgrounds, ideal for logos and graphics
+- Color depth: PNG maintains full color fidelity without compression artifacts
+- Resolution: Lower DPI (72-96) is typically sufficient for web use
+
+### TIFF Conversion Options
+
+TIFF is preferred for high-quality document archiving:
+
+```python
+# Tutorial Code Example: TIFF-Specific Conversion Options
+conversion_settings = {
+ "Format": "tiff",
+ "FilePath": "documents/contract.pdf",
+ "ConvertOptions": {
+ "Width": 2480, # A4 size at 300 DPI
+ "Height": 3508, # A4 size at 300 DPI
+ "HorizontalResolution": 300, # Print-quality resolution
+ "VerticalResolution": 300, # Print-quality resolution
+ "Compression": "lzw", # LZW lossless compression
+ "Grayscale": False, # Keep color information
+ "RotateAngle": 0, # No rotation
+ "BackgroundColor": "white" # White background
+ },
+ "OutputPath": "converted/archives/"
+}
+```
+
+Key TIFF-specific considerations:
+- Compression: TIFF supports multiple compression types:
+ - `lzw`: Good balance between size and quality (lossless)
+ - `ccitt4`: Ideal for black and white documents
+ - `none`: Uncompressed for maximum quality
+- Multi-page support: TIFF naturally supports multi-page documents
+- Resolution: Higher DPI (300+) for archival quality
+
+### Try it yourself
+
+Create conversion settings for converting a colorful brochure to a web-optimized WebP image:
+
+```python
+# Exercise: Create WebP-Specific ConvertOptions for web optimization
+# Your code here:
+conversion_settings = {
+ "Format": "webp",
+ "FilePath": "documents/brochure.pdf",
+ "ConvertOptions": {
+ "Width": 1200,
+ "Height": 1600,
+ "HorizontalResolution": 96,
+ "VerticalResolution": 96,
+ "Lossless": False, # Use lossy compression for smaller file size
+ "Grayscale": False, # Keep colors for brochure
+ "RotateAngle": 0,
+ "BackgroundColor": "white"
+ },
+ "OutputPath": "converted/web_images/"
+}
+```
+
+## Step 2: PDF Format Conversion Options
+
+PDF conversion offers extensive format-specific options:
+
+### High-Quality Print PDF
+
+For print-ready PDF conversion:
+
+```python
+# Tutorial Code Example: Print-Quality PDF Conversion Options
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/annual_report.docx",
+ "ConvertOptions": {
+ "Width": 8.27, # A4 width in inches
+ "Height": 11.69, # A4 height in inches
+ "Dpi": 300, # Print-quality DPI
+ "PdfFormat": "v1.7", # Modern PDF format
+ "MarginTop": 0.5, # 0.5 inch margins
+ "MarginBottom": 0.5,
+ "MarginLeft": 0.5,
+ "MarginRight": 0.5,
+ "RemovePdfACompliance": False, # Maintain PDF/A compliance if present
+ "Linearize": False, # Not needed for print
+ "LinkDuplicateStreams": True, # Optimize size
+ "RemoveUnusedObjects": True, # Optimize size
+ "RemoveUnusedStreams": True, # Optimize size
+ "CompressImages": False, # Maintain full image quality
+ "ImageQuality": 100, # Maximum image quality
+ "UnembedFonts": False, # Keep all fonts embedded
+ "Grayscale": False, # Keep color information
+ "Zoom": 100 # Normal zoom level
+ },
+ "OutputPath": "converted/print_ready/"
+}
+```
+
+### Web-Optimized PDF
+
+For web and digital distribution:
+
+```python
+# Tutorial Code Example: Web-Optimized PDF Conversion Options
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/whitepaper.docx",
+ "ConvertOptions": {
+ "Width": 8.27, # A4 width in inches
+ "Height": 11.69, # A4 height in inches
+ "Dpi": 150, # Lower DPI for web
+ "PdfFormat": "v1.7", # Modern PDF format
+ "MarginTop": 0.5, # Standard margins
+ "MarginBottom": 0.5,
+ "MarginLeft": 0.5,
+ "MarginRight": 0.5,
+ "Linearize": True, # Optimize for web viewing
+ "LinkDuplicateStreams": True, # Reduce file size
+ "RemoveUnusedObjects": True, # Reduce file size
+ "RemoveUnusedStreams": True, # Reduce file size
+ "CompressImages": True, # Compress images
+ "ImageQuality": 80, # Good balance of quality and size
+ "UnembedFonts": False, # Keep fonts for compatibility
+ "Grayscale": False, # Keep color information
+ "Zoom": 100 # Normal zoom level
+ },
+ "OutputPath": "converted/web_ready/"
+}
+```
+
+### Secure PDF
+
+For creating password-protected PDF documents:
+
+```python
+# Tutorial Code Example: Secure PDF Conversion Options
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/confidential_report.docx",
+ "ConvertOptions": {
+ "Width": 8.27, # A4 width in inches
+ "Height": 11.69, # A4 height in inches
+ "Dpi": 300, # High quality
+ "Password": "SecureP@ss2023!", # Set password protection
+ "PdfFormat": "v1.7", # Modern PDF format
+ "MarginTop": 0.5, # Standard margins
+ "MarginBottom": 0.5,
+ "MarginLeft": 0.5,
+ "MarginRight": 0.5,
+ "Linearize": True, # Optimize for viewing
+ "CompressImages": True, # Compress images
+ "ImageQuality": 90, # High quality images
+ "Grayscale": False, # Keep color information
+ "WatermarkOptions": { # Add watermark for extra security
+ "Text": "CONFIDENTIAL",
+ "Font": "Arial",
+ "Color": "red",
+ "Width": 500,
+ "Height": 100,
+ "RotationAngle": 45,
+ "Transparency": 0.5
+ }
+ },
+ "OutputPath": "converted/secure_pdfs/"
+}
+```
+
+Key PDF-specific considerations:
+- PDF Format: Choose appropriate version based on feature needs
+ - `v1.7`: Modern standard with good compatibility
+ - `v1.5`: Older version for wider compatibility
+ - `pdf/a-1a`, `pdf/a-1b`: For archival requirements
+- Linearization: Enables "fast web view" for faster loading online
+- Image compression: Critical for controlling file size
+- Security options: Password protection for sensitive documents
+
+### Try it yourself
+
+Create conversion settings for an archival-quality PDF/A document:
+
+```python
+# Exercise: Create PDF/A Conversion Options for archival purposes
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/legal_agreement.docx",
+ "ConvertOptions": {
+ "Width": 8.27,
+ "Height": 11.69,
+ "Dpi": 300,
+ "PdfFormat": "pdf/a-1b", # PDF/A format for archiving
+ "MarginTop": 0.75,
+ "MarginBottom": 0.75,
+ "MarginLeft": 1.0,
+ "MarginRight": 1.0,
+ "RemovePdfACompliance": False, # Maintain PDF/A compliance
+ "Linearize": False,
+ "LinkDuplicateStreams": True,
+ "RemoveUnusedObjects": True,
+ "RemoveUnusedStreams": True,
+ "CompressImages": False, # No image compression for archival quality
+ "UnembedFonts": False, # Embed all fonts
+ "Grayscale": False
+ },
+ "OutputPath": "converted/archival/"
+}
+```
+
+## Step 3: Office Document Format Options
+
+### Word Processing Formats (DOCX, DOC, RTF)
+
+For Word document formats:
+
+```python
+# Tutorial Code Example: Word Processing Conversion Options
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "documents/report.pdf",
+ "ConvertOptions": {
+ "Width": 8.5, # Letter width in inches
+ "Height": 11, # Letter height in inches
+ "Dpi": 300, # Document DPI
+ "Password": "", # No password protection
+ "Zoom": 100, # Normal zoom level
+ "PdfRecognitionMode": "Flow", # Recognize PDF content as flowing text
+ "PageSize": "Letter", # Page size
+ "PageOrientation": "Portrait" # Page orientation
+ },
+ "OutputPath": "converted/word_docs/"
+}
+```
+
+Key Word format considerations:
+- PDF Recognition Mode: Critical when converting from PDF
+ - `Textbox`: Preserves layout using text boxes
+ - `Flow`: Creates flowing text, better for editing
+- Page Size: Determines the document dimensions
+- Zoom: Affects how content is scaled
+
+### Spreadsheet Formats (XLSX, XLS, CSV)
+
+For Excel and other spreadsheet formats:
+
+```python
+# Tutorial Code Example: Spreadsheet Conversion Options
+conversion_settings = {
+ "Format": "xlsx",
+ "FilePath": "documents/data_table.pdf",
+ "ConvertOptions": {
+ "Password": "", # No password protection
+ "Zoom": 100, # Normal zoom level
+ "FromPage": 1, # Start from first page
+ "PagesCount": 0, # Convert all pages
+ "UsePdf": false # Direct conversion without PDF intermediary
+ },
+ "OutputPath": "converted/spreadsheets/"
+}
+```
+
+Key Spreadsheet format considerations:
+- Limited Options: Spreadsheet formats have fewer format-specific options
+- Handling Tables: When converting from other formats, table structure is preserved
+- CSV Specifics: When targeting CSV, be aware that formatting and multiple sheets are lost
+
+### Presentation Formats (PPTX, PPT)
+
+For PowerPoint and other presentation formats:
+
+```python
+# Tutorial Code Example: Presentation Conversion Options
+conversion_settings = {
+ "Format": "pptx",
+ "FilePath": "documents/report.pdf",
+ "ConvertOptions": {
+ "Password": "", # No password protection
+ "Zoom": 100, # Normal zoom level
+ "FromPage": 1, # Start from first page
+ "PagesCount": 0, # Convert all pages
+ "UsePdf": false # Direct conversion without PDF intermediary
+ },
+ "OutputPath": "converted/presentations/"
+}
+```
+
+Key Presentation format considerations:
+- Layout Preservation: Focus on maintaining visual layout and slide structure
+- Media Support: PPTX supports embedded media better than PPT
+- Animation: Most conversions do not preserve animations from other formats
+
+### Try it yourself
+
+Create conversion settings for converting a PDF document to DOCX with flow-based text recognition:
+
+```python
+# Exercise: Create Word Processing ConvertOptions with optimal text flow
+# Your code here:
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "documents/article.pdf",
+ "ConvertOptions": {
+ "Width": 8.5,
+ "Height": 11,
+ "Dpi": 300,
+ "PdfRecognitionMode": "Flow", # Better for editing text
+ "PageSize": "Letter",
+ "PageOrientation": "Portrait",
+ "FromPage": 1,
+ "PagesCount": 0 # Convert all pages
+ },
+ "OutputPath": "converted/editable_docs/"
+}
+```
+
+## Step 4: Advanced Format-Specific Options by Document Type
+
+### HTML Conversion Options
+
+HTML conversion offers special format-specific options:
+
+```python
+# Tutorial Code Example: HTML Conversion Options
+conversion_settings = {
+ "Format": "html",
+ "FilePath": "documents/newsletter.docx",
+ "ConvertOptions": {
+ "FixedLayout": True, # Maintain precise layout
+ "Zoom": 100, # Normal zoom level
+ "FromPage": 1, # Start from first page
+ "PagesCount": 0, # Convert all pages
+ "UsePdf": false, # Direct conversion
+ "WatermarkOptions": { # Optional watermark
+ "Text": "PREVIEW",
+ "Font": "Arial",
+ "Color": "lightgray",
+ "Width": 400,
+ "Height": 80,
+ "RotationAngle": 30,
+ "Transparency": 0.7
+ }
+ },
+ "OutputPath": "converted/web_pages/"
+}
+```
+
+Key HTML-specific considerations:
+- Fixed Layout: Controls whether the HTML uses fixed positioning or flowing layout
+- Responsive Design: When `FixedLayout` is `false`, content is more responsive
+- Browser Compatibility: HTML output is designed for modern browsers
+
+### E-book Formats (EPUB)
+
+EPUB conversion has options for digital book creation:
+
+```python
+# Tutorial Code Example: EPUB Conversion Options
+conversion_settings = {
+ "Format": "epub",
+ "FilePath": "documents/book_manuscript.docx",
+ "ConvertOptions": {
+ "PageSize": "A5", # Common e-reader size
+ "PageOrientation": "Portrait",
+ "FromPage": 1,
+ "PagesCount": 0,
+ "WatermarkOptions": { # Optional watermark
+ "Text": "SAMPLE",
+ "Font": "Times New Roman",
+ "Color": "gray",
+ "Transparency": 0.8
+ }
+ },
+ "OutputPath": "converted/ebooks/"
+}
+```
+
+Key EPUB-specific considerations:
+- Page Size: Affects the default display size on e-readers
+- Content Structure: EPUB preserves document structure for reflowable content
+- Metadata: Source document properties often become EPUB metadata
+
+### SVG Vector Graphics
+
+SVG conversion options focus on vector quality:
+
+```python
+# Tutorial Code Example: SVG Conversion Options
+conversion_settings = {
+ "Format": "svg",
+ "FilePath": "documents/diagram.pdf",
+ "ConvertOptions": {
+ "FromPage": 1, # Start from first page
+ "PagesCount": 1, # Usually convert one page at a time for SVG
+ "WatermarkOptions": None # No watermark for clean vector output
+ },
+ "OutputPath": "converted/vectors/"
+}
+```
+
+Key SVG-specific considerations:
+- Vector Preservation: SVG maintains vector quality at any scale
+- Text Handling: Text elements in source documents are preserved as text in SVG
+- Single Page: SVG is typically used for single-page conversions
+
+### Try it yourself
+
+Create conversion settings for converting a report to an EPUB e-book format with custom page size:
+
+```python
+# Exercise: Create EPUB ConvertOptions for e-reader optimization
+# Your code here:
+conversion_settings = {
+ "Format": "epub",
+ "FilePath": "documents/technical_manual.docx",
+ "ConvertOptions": {
+ "PageSize": "A6", # Smaller size for e-readers
+ "PageOrientation": "Portrait",
+ "FromPage": 1,
+ "PagesCount": 0, # Convert all pages
+ "WatermarkOptions": None # No watermark
+ },
+ "OutputPath": "converted/technical_guides/"
+}
+```
+
+## Implementation Examples
+
+Let's see how to implement format-specific options with the API in different languages:
+
+### cURL Example (JPEG with Quality Options)
+
+```bash
+# Tutorial Code Example: Using Format-Specific Options with cURL
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "Format": "jpeg",
+ "FilePath": "documents/presentation.pptx",
+ "ConvertOptions": {
+ "Width": 1920,
+ "Height": 1080,
+ "Quality": 85,
+ "FromPage": 1,
+ "PagesCount": 0,
+ "Grayscale": false
+ },
+ "OutputPath": "converted/"
+ }'
+```
+
+### Python Example (PDF with Security Options)
+
+```python
+# Tutorial Code Example: Using Format-Specific Options with Python SDK
+import groupdocs_conversion_cloud
+
+# Configure the API client
+configuration = groupdocs_conversion_cloud.Configuration(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET"
+)
+api_client = groupdocs_conversion_cloud.ApiClient(configuration)
+api = groupdocs_conversion_cloud.ConvertApi(api_client)
+
+# Create conversion settings
+settings = groupdocs_conversion_cloud.ConvertSettings()
+settings.file_path = "documents/confidential.docx"
+settings.format = "pdf"
+
+# Configure PDF-specific convert options
+convert_options = groupdocs_conversion_cloud.PdfConvertOptions()
+convert_options.width = 8.27 # A4 width in inches
+convert_options.height = 11.69 # A4 height in inches
+convert_options.dpi = 300
+convert_options.password = "SecureP@ss2023!" # Set password protection
+convert_options.pdf_format = "v1.7"
+convert_options.linearize = True
+convert_options.compress_images = True
+convert_options.image_quality = 90
+
+# Create watermark options
+watermark = groupdocs_conversion_cloud.WatermarkOptions()
+watermark.text = "CONFIDENTIAL"
+watermark.font = "Arial"
+watermark.color = "red"
+watermark.width = 500
+watermark.height = 100
+watermark.rotation_angle = 45
+watermark.transparency = 0.5
+convert_options.watermark_options = [watermark]
+
+settings.convert_options = convert_options
+settings.output_path = "converted/secure_pdfs/"
+
+# Execute conversion
+result = api.convert(settings)
+print(f"Document converted successfully! Results: {result}")
+```
+
+### C# Example (DOCX with Flow Text Options)
+
+```csharp
+// Tutorial Code Example: Using Format-Specific Options with C# SDK
+using GroupDocs.Conversion.Cloud.Sdk;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Configure the API client
+var configuration = new Configuration
+{
+ ClientId = "YOUR_CLIENT_ID",
+ ClientSecret = "YOUR_CLIENT_SECRET"
+};
+var apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+var settings = new ConvertSettings
+{
+ FilePath = "documents/report.pdf",
+ Format = "docx",
+ ConvertOptions = new WordProcessingConvertOptions
+ {
+ Width = 8.5f,
+ Height = 11f,
+ Dpi = 300,
+ PdfRecognitionMode = "Flow", // Recognize PDF content as flowing text
+ PageSize = "Letter",
+ PageOrientation = "Portrait"
+ },
+ OutputPath = "converted/word_docs/"
+};
+
+// Execute conversion
+var result = apiInstance.Convert(new ConvertRequest(settings));
+Console.WriteLine($"Document converted successfully! Results: {result.Count} files");
+```
+
+### Java Example (TIFF with Compression Options)
+
+```java
+// Tutorial Code Example: Using Format-Specific Options with Java SDK
+import com.groupdocs.conversion.cloud.api.ConvertApi;
+import com.groupdocs.conversion.cloud.api.model.*;
+import com.groupdocs.conversion.cloud.api.model.requests.ConvertRequest;
+
+// Configure the API client
+Configuration configuration = new Configuration();
+configuration.setClientId("YOUR_CLIENT_ID");
+configuration.setClientSecret("YOUR_CLIENT_SECRET");
+ConvertApi apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+ConvertSettings settings = new ConvertSettings();
+settings.setFilePath("documents/scan.pdf");
+settings.setFormat("tiff");
+
+// Configure TIFF-specific convert options
+TiffConvertOptions convertOptions = new TiffConvertOptions();
+convertOptions.setWidth(2480); // A4 size at 300 DPI
+convertOptions.setHeight(3508);
+convertOptions.setHorizontalResolution(300);
+convertOptions.setVerticalResolution(300);
+convertOptions.setCompression("lzw"); // LZW lossless compression
+convertOptions.setGrayscale(true); // Convert to grayscale
+settings.setConvertOptions(convertOptions);
+
+settings.setOutputPath("converted/archives/");
+
+// Execute conversion
+List result = apiInstance.convert(new ConvertRequest(settings));
+System.out.println("Document converted successfully! Results: " + result.size() + " files");
+```
+
+## Format-Specific Option Reference Tables
+
+### Image Format Options
+
+| Option | JPG/JPEG | PNG | TIFF | WebP | BMP | PSD |
+|--------|----------|-----|------|------|-----|-----|
+| Width | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Height | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| HorizontalResolution | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| VerticalResolution | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Quality | ✓ | - | - | - | - | - |
+| Compression | - | - | ✓ | - | - | ✓ |
+| Lossless | - | - | - | ✓ | - | - |
+| Grayscale | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| RotateAngle | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| BackgroundColor | ✓ | ✓ | ✓ | - | ✓ | - |
+| ChannelBitsCount | - | - | - | - | - | ✓ |
+| ChannelsCount | - | - | - | - | - | ✓ |
+| ColorMode | - | - | - | - | - | ✓ |
+
+### Document Format Options
+
+| Option | PDF | DOCX/DOC | XLSX/XLS | PPTX/PPT | HTML | EPUB |
+|--------|-----|----------|----------|----------|------|------|
+| Width | ✓ | ✓ | - | - | - | - |
+| Height | ✓ | ✓ | - | - | - | - |
+| Dpi | ✓ | ✓ | - | - | - | - |
+| Password | ✓ | ✓ | ✓ | ✓ | - | - |
+| PdfFormat | ✓ | - | - | - | - | - |
+| MarginTop/Bottom/Left/Right | ✓ | - | - | - | - | - |
+| Zoom | ✓ | ✓ | ✓ | ✓ | ✓ | - |
+| Grayscale | ✓ | - | - | - | - | - |
+| CompressImages | ✓ | - | - | - | - | - |
+| ImageQuality | ✓ | - | - | - | - | - |
+| PdfRecognitionMode | - | ✓ | - | - | - | - |
+| PageSize | - | ✓ | - | - | - | ✓ |
+| PageOrientation | - | ✓ | - | - | - | ✓ |
+| FixedLayout | - | - | - | - | ✓ | - |
+| UsePdf | ✓ | ✓ | ✓ | ✓ | ✓ | - |
+| WatermarkOptions | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+
+## Tips and Best Practices
+
+### 1. Choose the Right Format for Your Use Case
+
+Select the optimal target format based on your needs:
+- JPEG: For photographs and web images where some quality loss is acceptable
+- PNG: For graphics, screenshots, and images needing transparency
+- TIFF: For archival images and documents requiring lossless quality
+- PDF: For documents that need to maintain exact layout and formatting
+- DOCX: For documents that will need further editing
+- SVG: For vector graphics that need to scale without quality loss
+
+### 2. Optimize for File Size vs. Quality
+
+Balance quality and file size based on your distribution method:
+- Web delivery: Favor smaller file sizes (higher compression, lower resolution)
+- Print production: Prioritize quality (minimal compression, higher resolution)
+- Email distribution: Balance moderate quality with reasonable file sizes
+- Archiving: Favor quality and format longevity over file size
+
+### 3. Use Format-Specific Features Strategically
+
+Leverage unique features of each format:
+- Use PDF security options for sensitive documents
+- Take advantage of PNG transparency for logos and graphics
+- Use TIFF compression options for large document archives
+- Leverage EPUB page sizing for optimal e-reader display
+
+### 4. Test and Validate Conversions
+
+Always test your conversion results:
+- Verify that the output meets your quality expectations
+- Check that all content is preserved correctly
+- Validate in the target environment (web browser, e-reader, etc.)
+- Compare multiple format options to find the optimal settings
+
+## Troubleshooting Format-Specific Issues
+
+### Issue 1: Poor Image Quality in JPEG
+If JPEG images look pixelated or have compression artifacts:
+- Increase the `Quality` parameter (85-95 for high quality)
+- Increase resolution for images containing text or fine details
+- Consider using PNG for graphics with sharp edges and text
+
+### Issue 2: Large File Sizes in PDF
+If PDF files are too large:
+- Enable `CompressImages` and adjust `ImageQuality` to 80-85
+- Use `RemoveUnusedObjects` and `RemoveUnusedStreams`
+- Enable `LinkDuplicateStreams` to optimize repeated content
+- Consider grayscale for documents without essential color information
+
+### Issue 3: Text Recognition Problems in DOCX
+If text isn't properly recognized when converting to DOCX:
+- Try different `PdfRecognitionMode` values (`Flow` vs. `Textbox`)
+- Ensure the source document has clear, high-quality text
+- For scanned documents, consider OCR processing before conversion
+
+### Issue 4: Content Loss in Format Conversion
+If content is missing after conversion:
+- Check if the source format has features not supported in the target format
+- Verify that all pages are included (check `FromPage` and `PagesCount`)
+- Try using `UsePdf: true` as an intermediary for complex conversions
+- For Office formats, ensure embedded objects are properly handled
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- How to configure format-specific conversion options for optimal results
+- Advanced techniques for optimizing document conversions across different formats
+- Best practices for selecting the right conversion options by format
+- How to troubleshoot format-specific conversion issues
+- Implementation examples in multiple programming languages
+
+## Further Practice
+
+To reinforce your understanding:
+1. Create a test suite that converts the same document to multiple formats with optimized settings
+2. Build a tool that allows users to select format-specific options based on their use case
+3. Experiment with different compression and quality settings to find optimal configurations
+4. Create presets for common conversion scenarios (web publishing, print production, archiving)
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about format-specific conversion options? Need clarification on any part of this tutorial? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
\ No newline at end of file
diff --git a/content/conversion/english/data-organization/load-options/_index.md b/content/conversion/english/data-organization/load-options/_index.md
new file mode 100644
index 0000000..b8af26a
--- /dev/null
+++ b/content/conversion/english/data-organization/load-options/_index.md
@@ -0,0 +1,544 @@
+---
+title: Understanding Load Options in Document Conversion Tutorial
+weight: 20
+url: /data-organization/load-options/
+description: Learn how to properly configure document loading options for optimal conversion results with this hands-on tutorial for GroupDocs.Conversion Cloud API
+---
+
+# Tutorial: Understanding Load Options in Document Conversion
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- What LoadOptions are and why they're crucial for document conversion
+- How to configure format-specific loading parameters
+- Techniques for handling password-protected documents
+- Best practices for optimizing document loading across different formats
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A [GroupDocs.Conversion Cloud account](https://dashboard.groupdocs.cloud/#/apps)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST API concepts
+- Familiarity with JSON data structures
+- A development environment set up for your preferred language (examples provided in cURL, Python, Java, and C#)
+
+## What are LoadOptions?
+
+LoadOptions control how GroupDocs.Conversion Cloud API reads and processes input documents before conversion. They allow you to specify format-specific parameters that affect how the document is loaded and interpreted.
+
+Different document formats have different loading requirements and options. Providing the right LoadOptions ensures your documents are correctly interpreted before the conversion process begins, leading to better quality conversion results.
+
+## Why LoadOptions Matter
+
+Consider these scenarios where LoadOptions make a significant difference:
+
+1. Password-protected documents: Without the correct password in LoadOptions, protected documents can't be opened at all
+2. Spreadsheets: Options like showing/hiding gridlines, formulas, or specific worksheets affect conversion appearance
+3. Presentations: Control whether hidden slides are included in the conversion
+4. PDF documents: Configure how annotations and embedded files are handled
+5. Email messages: Determine which fields are displayed and how they're formatted
+
+Let's explore how to implement LoadOptions for different document formats.
+
+## Step 1: Understanding the Basic Structure
+
+LoadOptions are always included as part of the ConversionSettings object:
+
+```json
+{
+ "Format": "pdf",
+ "FilePath": "documents/sample.docx",
+ "LoadOptions": {
+ // Format-specific loading options go here
+ },
+ "OutputPath": "converted/"
+}
+```
+
+The specific properties available in LoadOptions depend on the input document format.
+
+## Step 2: Working with General Document Properties
+
+Some properties are common across multiple document formats:
+
+### Password Protection
+
+Most document formats support password protection, which you can handle like this:
+
+```python
+# Tutorial Code Example: Password-Protected Documents
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/protected.docx",
+ "LoadOptions": {
+ "Password": "your-secure-password" # Document password
+ },
+ "OutputPath": "converted/"
+}
+```
+
+### Default Font Handling
+
+Many formats allow you to specify a default font:
+
+```python
+# Tutorial Code Example: Default Font Setting
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/custom_fonts.docx",
+ "LoadOptions": {
+ "DefaultFont": "Arial" # Font to use if original fonts are missing
+ },
+ "OutputPath": "converted/"
+}
+```
+
+### Try it yourself
+
+Create LoadOptions for a password-protected PDF document with specific font handling:
+
+```python
+# Exercise: Create LoadOptions for a protected PDF
+# Your code here:
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "documents/secured_report.pdf",
+ "LoadOptions": {
+ "Password": "pdf-password-2023",
+ "DefaultFont": "Times New Roman"
+ },
+ "OutputPath": "converted/documents/"
+}
+```
+
+## Step 3: Format-Specific LoadOptions
+
+Let's explore LoadOptions for specific document formats:
+
+### Spreadsheet LoadOptions (Excel, CSV, etc.)
+
+Spreadsheet documents have several unique loading options:
+
+```python
+# Tutorial Code Example: Spreadsheet LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "spreadsheets/financial_data.xlsx",
+ "LoadOptions": {
+ "DefaultFont": "Arial",
+ "FontSubstitutes": [],
+ "ShowGridLines": True, # Show/hide spreadsheet gridlines
+ "ShowHiddenSheets": False, # Include/exclude hidden worksheets
+ "OnePagePerSheet": True, # Put each worksheet on a separate page
+ "ConvertRange": "D1:F8", # Convert only a specific range of cells
+ "SkipEmptyRowsAndColumns": True, # Ignore empty rows/columns
+ "Password": "excel-password",
+ "HideComment": True # Hide cell comments
+ },
+ "OutputPath": "converted/reports/"
+}
+```
+
+### CSV-Specific LoadOptions
+
+CSV files have their own special options:
+
+```python
+# Tutorial Code Example: CSV LoadOptions
+conversion_settings = {
+ "Format": "xlsx",
+ "FilePath": "data/statistics.csv",
+ "LoadOptions": {
+ "Separator": ",", # CSV delimiter character
+ "IsMultiEncoded": False, # Handle multiple encodings
+ "HasFormula": True, # Treat text starting with "=" as formulas
+ "ConvertNumericData": True, # Convert string values to numbers where possible
+ "ConvertDateTimeData": True # Convert string values to dates where possible
+ },
+ "OutputPath": "converted/spreadsheets/"
+}
+```
+
+### Presentation LoadOptions (PowerPoint)
+
+Presentation documents have format-specific options:
+
+```python
+# Tutorial Code Example: Presentation LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "presentations/quarterly_update.pptx",
+ "LoadOptions": {
+ "DefaultFont": "Calibri",
+ "FontSubstitutes": [],
+ "Password": "presentation-password",
+ "ShowHiddenSlides": False, # Include/exclude hidden slides
+ "HideComment": True # Hide presentation comments
+ },
+ "OutputPath": "converted/slides/"
+}
+```
+
+### Try it yourself
+
+Create LoadOptions for an Excel file where you want to convert all sheets, show gridlines, and handle hidden content:
+
+```python
+# Exercise: Create LoadOptions for Excel with specific requirements
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "spreadsheets/annual_budget.xlsx",
+ "LoadOptions": {
+ "ShowGridLines": True,
+ "ShowHiddenSheets": True,
+ "OnePagePerSheet": True,
+ "SkipEmptyRowsAndColumns": True,
+ "Password": "budget2023"
+ },
+ "OutputPath": "converted/financial/"
+}
+```
+
+## Step 4: Advanced LoadOptions by Document Type
+
+### PDF LoadOptions
+
+PDF documents have specific loading options:
+
+```python
+# Tutorial Code Example: PDF LoadOptions
+conversion_settings = {
+ "Format": "docx",
+ "FilePath": "documents/technical_manual.pdf",
+ "LoadOptions": {
+ "RemoveEmbeddedFiles": False, # Keep embedded files
+ "Password": "pdf-password",
+ "HidePdfAnnotations": True, # Hide annotations
+ "FlattenAllFields": True # Flatten form fields
+ },
+ "OutputPath": "converted/manuals/"
+}
+```
+
+### Email LoadOptions (MSG, EML)
+
+Email formats have unique options for controlling displayed content:
+
+```python
+# Tutorial Code Example: Email LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "emails/important_message.msg",
+ "LoadOptions": {
+ "DisplayHeader": True, # Show email header
+ "DisplayFromEmailAddress": True, # Show sender email address
+ "DisplayEmailAddress": True, # Show all email addresses
+ "DisplayToEmailAddress": True, # Show recipient(s)
+ "DisplayCcEmailAddress": True, # Show CC recipients
+ "DisplayBccEmailAddress": True, # Show BCC recipients
+ "FieldLabels": [
+ {
+ "Field": "From",
+ "Label": "Sender"
+ }
+ ],
+ "PreserveOriginalDate": True # Keep original email date
+ },
+ "OutputPath": "converted/correspondence/"
+}
+```
+
+### Word Processing LoadOptions (DOCX, DOC, RTF)
+
+Word documents have several loading options:
+
+```python
+# Tutorial Code Example: Word Processing LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "documents/contract.docx",
+ "LoadOptions": {
+ "DefaultFont": "Times New Roman",
+ "FontSubstitutes": [],
+ "AutoFontSubstitution": True, # Automatically substitute missing fonts
+ "Password": "doc-password",
+ "HideWordTrackedChanges": True, # Hide tracked changes/revisions
+ "HideComment": True # Hide document comments
+ },
+ "OutputPath": "converted/legal/"
+}
+```
+
+### Image LoadOptions (TIFF, JPG, PNG)
+
+Image formats have simpler loading options:
+
+```python
+# Tutorial Code Example: Image LoadOptions
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "images/diagram.tiff",
+ "LoadOptions": {
+ "DefaultFont": "Arial" # Font for text elements in vector images
+ },
+ "OutputPath": "converted/images/"
+}
+```
+
+### Try it yourself
+
+Create LoadOptions for an email message where you want to customize the display of certain fields:
+
+```python
+# Exercise: Create LoadOptions for Email with custom field display
+# Your code here:
+conversion_settings = {
+ "Format": "pdf",
+ "FilePath": "emails/client_request.eml",
+ "LoadOptions": {
+ "DisplayHeader": True,
+ "DisplayFromEmailAddress": True,
+ "DisplayEmailAddress": False,
+ "DisplayToEmailAddress": True,
+ "DisplayCcEmailAddress": True,
+ "DisplayBccEmailAddress": False,
+ "FieldLabels": [
+ {
+ "Field": "From",
+ "Label": "Sent By"
+ },
+ {
+ "Field": "To",
+ "Label": "Recipients"
+ }
+ ]
+ },
+ "OutputPath": "converted/client_communications/"
+}
+```
+
+## Implementation Examples
+
+Let's see how to implement LoadOptions with the API:
+
+### cURL Example
+
+```bash
+# Tutorial Code Example: Using LoadOptions with cURL
+curl -X POST "https://api.groupdocs.cloud/v2.0/conversion" \
+ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "Format": "pdf",
+ "FilePath": "spreadsheets/financial_report.xlsx",
+ "LoadOptions": {
+ "Password": "secure123",
+ "ShowGridLines": false,
+ "ShowHiddenSheets": false,
+ "OnePagePerSheet": true
+ },
+ "OutputPath": "converted/"
+ }'
+```
+
+### Python Example
+
+```python
+# Tutorial Code Example: Using LoadOptions with Python SDK
+import groupdocs_conversion_cloud
+
+# Configure the API client
+configuration = groupdocs_conversion_cloud.Configuration(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET"
+)
+api_client = groupdocs_conversion_cloud.ApiClient(configuration)
+api = groupdocs_conversion_cloud.ConvertApi(api_client)
+
+# Create conversion settings
+settings = groupdocs_conversion_cloud.ConvertSettings()
+settings.file_path = "spreadsheets/financial_report.xlsx"
+settings.format = "pdf"
+
+# Configure Excel-specific load options
+load_options = groupdocs_conversion_cloud.SpreadsheetLoadOptions()
+load_options.password = "secure123"
+load_options.show_grid_lines = False
+load_options.show_hidden_sheets = False
+load_options.one_page_per_sheet = True
+settings.load_options = load_options
+
+settings.output_path = "converted/"
+
+# Execute conversion
+result = api.convert(settings)
+print(f"Document converted successfully! Results: {result}")
+```
+
+### C# Example
+
+```csharp
+// Tutorial Code Example: Using LoadOptions with C# SDK
+using GroupDocs.Conversion.Cloud.Sdk;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Configure the API client
+var configuration = new Configuration
+{
+ ClientId = "YOUR_CLIENT_ID",
+ ClientSecret = "YOUR_CLIENT_SECRET"
+};
+var apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+var settings = new ConvertSettings
+{
+ FilePath = "spreadsheets/financial_report.xlsx",
+ Format = "pdf",
+ LoadOptions = new SpreadsheetLoadOptions
+ {
+ Password = "secure123",
+ ShowGridLines = false,
+ ShowHiddenSheets = false,
+ OnePagePerSheet = true
+ },
+ OutputPath = "converted/"
+};
+
+// Execute conversion
+var result = apiInstance.Convert(new ConvertRequest(settings));
+Console.WriteLine($"Document converted successfully! Results: {result.Count} files");
+```
+
+### Java Example
+
+```java
+// Tutorial Code Example: Using LoadOptions with Java SDK
+import com.groupdocs.conversion.cloud.api.ConvertApi;
+import com.groupdocs.conversion.cloud.api.model.*;
+import com.groupdocs.conversion.cloud.api.model.requests.ConvertRequest;
+
+// Configure the API client
+Configuration configuration = new Configuration();
+configuration.setClientId("YOUR_CLIENT_ID");
+configuration.setClientSecret("YOUR_CLIENT_SECRET");
+ConvertApi apiInstance = new ConvertApi(configuration);
+
+// Create conversion settings
+ConvertSettings settings = new ConvertSettings();
+settings.setFilePath("spreadsheets/financial_report.xlsx");
+settings.setFormat("pdf");
+
+// Configure Excel-specific load options
+SpreadsheetLoadOptions loadOptions = new SpreadsheetLoadOptions();
+loadOptions.setPassword("secure123");
+loadOptions.setShowGridLines(false);
+loadOptions.setShowHiddenSheets(false);
+loadOptions.setOnePagePerSheet(true);
+settings.setLoadOptions(loadOptions);
+
+settings.setOutputPath("converted/");
+
+// Execute conversion
+List result = apiInstance.convert(new ConvertRequest(settings));
+System.out.println("Document converted successfully! Results: " + result.size() + " files");
+```
+
+## Tips and Best Practices
+
+### 1. Match LoadOptions to Document Type
+
+Always use the correct LoadOptions type for your document format:
+- Use `SpreadsheetLoadOptions` for Excel, CSV, and other spreadsheet formats
+- Use `WordProcessingLoadOptions` for Word documents
+- Use `PresentationLoadOptions` for PowerPoint files
+- Use `PdfLoadOptions` for PDF documents
+
+Using mismatched LoadOptions types will result in errors or unexpected behavior.
+
+### 2. Optimize for Output Format
+
+Consider your target format when setting load options:
+- When converting to image formats, focus on visual appearance settings
+- When converting to editable formats, prioritize content structure preservation
+- When converting to PDF, consider both appearance and document functionality
+
+### 3. Handle Special Characters and Encodings
+
+For text-based formats like CSV and TXT:
+- Specify the correct separators for CSV files
+- Set encoding options appropriately for international characters
+- Use `IsMultiEncoded` when dealing with mixed-encoding documents
+
+### 4. Font Management
+
+Font handling is critical for accurate document representation:
+- Always specify a `DefaultFont` for documents with custom fonts
+- Consider using `FontSubstitutes` for precise font replacement
+- Enable `AutoFontSubstitution` for automatic font fallback
+
+### 5. Security Considerations
+
+When dealing with protected documents:
+- Always provide the correct password in LoadOptions
+- Consider security implications when converting protected documents
+- Remember that passwords are sent as plain text in API requests
+
+## Troubleshooting Common Issues
+
+### Issue 1: Document Fails to Load
+If the document doesn't load properly:
+- Verify the password is correct (case-sensitive)
+- Check that you're using the correct LoadOptions type for the document format
+- Ensure the file exists and is accessible in your storage
+
+### Issue 2: Missing Content After Conversion
+If content is missing from converted documents:
+- For spreadsheets, check `ShowHiddenSheets` and `ConvertRange` settings
+- For presentations, verify `ShowHiddenSlides` configuration
+- For emails, ensure all display fields are properly configured
+
+### Issue 3: Font Problems
+If fonts appear incorrect:
+- Set a `DefaultFont` that is widely available
+- Configure `FontSubstitutes` for specific font replacements
+- Enable `AutoFontSubstitution` for automatic handling
+
+## What You've Learned
+
+In this tutorial, you've learned:
+- The purpose and importance of LoadOptions in document conversion
+- How to configure format-specific loading parameters
+- Techniques for handling password-protected documents
+- Best practices for optimizing document loading
+- Implementation examples in multiple programming languages
+
+## Further Practice
+
+To reinforce your understanding:
+1. Try loading different document formats with various LoadOptions configurations
+2. Experiment with password-protected documents in different formats
+3. Create a simple application that allows users to specify custom LoadOptions
+4. Test how different LoadOptions affect conversion quality for the same document
+
+## Next Steps
+
+Ready to expand your knowledge? Continue to our next tutorial: [Tutorial: Working with Convert Options](/data-organization/convert-options/) to learn how to control the output format and appearance during document conversion.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+## Feedback
+
+Have questions about working with LoadOptions? Need clarification on any part of this tutorial? We'd love to hear from you! Please visit our [support forum](https://forum.groupdocs.cloud/c/conversion/11) with any questions or feedback.
\ No newline at end of file
diff --git a/content/conversion/english/quick-start-guide/_index.md b/content/conversion/english/quick-start-guide/_index.md
new file mode 100644
index 0000000..70675ae
--- /dev/null
+++ b/content/conversion/english/quick-start-guide/_index.md
@@ -0,0 +1,60 @@
+---
+title: GroupDocs.Conversion Cloud API Quick Start Guide Tutorials
+weight: 1
+description: Step-by-step tutorials for developers to learn how to convert documents using GroupDocs.Conversion Cloud API
+url: /quick-start-guide/
+---
+
+# GroupDocs.Conversion Cloud API Quick Start Guide Tutorials
+
+Welcome to our comprehensive tutorial series for GroupDocs.Conversion Cloud API! These hands-on tutorials are designed specifically for developers who want to learn how to convert documents between various formats using our powerful cloud-based API.
+
+## Learning Path
+
+Follow this structured learning path to master document conversion with GroupDocs.Conversion Cloud:
+
+### Beginner Tutorials
+Start with these foundational tutorials to understand the basics of working with the API:
+
+1. [Tutorial: Learn About Supported File Formats](/quick-start-guide/supported-formats/) - Learn how to retrieve all supported conversion formats and understand which file types your applications can work with.
+
+2. [Tutorial: How to Convert Documents](/quick-start-guide/convert-document/) - Learn the fundamental process of converting documents from one format to another using cloud storage.
+
+3. [Tutorial: How to Convert Documents Without Storage](/quick-start-guide/convert-direct/) - Learn how to perform direct document conversions without using cloud storage for a more streamlined workflow.
+
+### Intermediate Tutorials
+Enhance your knowledge with these more detailed tutorials:
+
+4. [Tutorial: How to Get Document Metadata](/quick-start-guide/document-metadata/) - Learn how to retrieve and analyze document metadata to better understand your files before conversion.
+
+## Prerequisites for All Tutorials
+
+Before starting these tutorials, ensure you have:
+
+- A GroupDocs.Conversion Cloud account (sign up for a [free trial](https://dashboard.groupdocs.cloud/#/apps) if you don't have one)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST APIs and your preferred programming language
+- An IDE or code editor for your chosen language
+
+## What You'll Build
+
+Throughout these tutorials, you'll build applications that can:
+
+- Check supported document formats for conversion
+- Convert documents using cloud storage
+- Perform direct document conversions without storage
+- Extract and analyze document metadata
+
+By the end of this series, you'll have a comprehensive understanding of how to implement document conversion functionality in your applications using GroupDocs.Conversion Cloud API.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [Live Demo](https://products.groupdocs.app/conversion/family)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Blog](https://blog.groupdocs.cloud/categories/groupdocs.conversion-cloud-product-family/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We encourage your feedback and questions about these tutorials! Please use our [support forum](https://forum.groupdocs.cloud/c/conversion/11) if you need assistance or want to suggest improvements to our learning materials.
diff --git a/content/conversion/english/quick-start-guide/convert-direct/_index.md b/content/conversion/english/quick-start-guide/convert-direct/_index.md
new file mode 100644
index 0000000..ef2accd
--- /dev/null
+++ b/content/conversion/english/quick-start-guide/convert-direct/_index.md
@@ -0,0 +1,410 @@
+---
+title: How to Convert Documents Without Storage in GroupDocs.Conversion Cloud Tutorial
+weight: 3
+description: Learn how to convert documents directly without using cloud storage in this step-by-step tutorial for GroupDocs.Conversion Cloud API.
+url: /quick-start-guide/convert-direct/
+---
+
+# Tutorial: How to Convert Documents Without Storage in GroupDocs.Conversion Cloud
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- How to convert documents directly without using cloud storage
+- When and why to use direct conversion
+- How to handle conversion options and specialized settings
+- How to process the conversion results efficiently
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (get a [free trial](https://dashboard.groupdocs.cloud/#/apps) if needed)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST APIs
+- Familiarity with your preferred programming language (C#, Java, PHP, etc.)
+- Completed our [Basic Document Conversion tutorial](/quick-start-guide/convert-document/) (recommended)
+
+## Why Use Direct Conversion?
+
+Direct conversion (without storage) offers several advantages:
+- Simplified workflow: Skip the upload and download steps needed with storage-based conversion
+- Reduced latency: Convert documents in a single API call
+- Better privacy: Files aren't stored in the cloud
+- Reduced storage costs: No need to maintain files in cloud storage
+- Ideal for temporary conversions: Perfect for one-time, on-demand conversions
+
+## Tutorial Steps
+
+### Step 1: Understanding Direct Conversion
+
+Direct conversion allows you to convert documents without first uploading them to cloud storage. Instead, you send the file directly in the API request and receive the converted file in the response.
+
+The key differences from storage-based conversion are:
+- Uses a different API endpoint (PUT instead of POST)
+- Sends the file as form data in the request
+- Receives the converted file directly in the response
+
+### Step 2: Set Up Your Environment
+
+Let's start by setting up our development environment:
+
+#### Try it yourself:
+
+1. Create a new project in your preferred IDE
+2. Install the appropriate GroupDocs.Conversion Cloud SDK for your language
+3. Set up your authentication credentials:
+
+```csharp
+// C# example
+string MyClientSecret = ""; // Get from https://dashboard.groupdocs.cloud
+string MyClientId = ""; // Get from https://dashboard.groupdocs.cloud
+
+var configuration = new Configuration(MyClientId, MyClientSecret);
+
+// Create necessary API instance
+var apiInstance = new ConvertApi(configuration);
+```
+
+### Step 3: Convert a Document Directly
+
+Now, let's implement direct conversion:
+
+#### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=xxxx&client_secret=xxxx" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Convert document directly
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/conversion" \
+-X PUT \
+-H "Content-Type: multipart/form-data" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer " \
+--data-binary "@/path/to/file.docx"
+```
+
+#### Using C# SDK
+
+```csharp
+// Open the file
+var fileStream = File.Open("C:\\path\\to\\document.docx", FileMode.Open);
+
+// Create the request
+var request = new ConvertDocumentDirectRequest("pdf", fileStream);
+
+// Execute the API call
+var response = apiInstance.ConvertDocumentDirect(request);
+
+// Save the result to a file
+using (var outputStream = File.Create("C:\\path\\to\\output.pdf"))
+{
+ response.CopyTo(outputStream);
+}
+
+Console.WriteLine("Document converted successfully!");
+```
+
+### Step 4: Convert a Password-Protected Document
+
+If your document is password-protected, you need to provide the password using load options:
+
+#### Using C# SDK
+
+```csharp
+// Open the file
+var fileStream = File.Open("C:\\path\\to\\password-protected.docx", FileMode.Open);
+
+// Create load options with password
+var loadOptions = new DocxLoadOptions
+{
+ Format = "docx",
+ Password = "your-document-password"
+};
+
+// Create the request with load options
+var request = new ConvertDocumentDirectRequest("pdf", fileStream, null, null, loadOptions);
+
+// Execute the API call
+var response = apiInstance.ConvertDocumentDirect(request);
+
+// Save the result to a file
+using (var outputStream = File.Create("C:\\path\\to\\output.pdf"))
+{
+ response.CopyTo(outputStream);
+}
+
+Console.WriteLine("Password-protected document converted successfully!");
+```
+
+### Step 5: Specifying Conversion Options
+
+You can customize the conversion process by specifying conversion options:
+
+#### Using C# SDK
+
+```csharp
+// Open the file
+var fileStream = File.Open("C:\\path\\to\\document.docx", FileMode.Open);
+
+// Create load options if needed
+var loadOptions = new DocxLoadOptions
+{
+ Format = "docx"
+};
+
+// Create PDF conversion options
+var convertOptions = new PdfConvertOptions
+{
+ Dpi = 300,
+ Width = 800,
+ Height = 1200,
+ Password = "set-pdf-password", // Set password for output PDF
+ Grayscale = true,
+ MarginTop = 20,
+ MarginBottom = 20,
+ MarginLeft = 20,
+ MarginRight = 20
+};
+
+// Create the request with all options
+var request = new ConvertDocumentDirectRequest("pdf", fileStream,
+ null, null, loadOptions, convertOptions);
+
+// Execute the API call
+var response = apiInstance.ConvertDocumentDirect(request);
+
+// Save the result to a file
+using (var outputStream = File.Create("C:\\path\\to\\output.pdf"))
+{
+ response.CopyTo(outputStream);
+}
+
+Console.WriteLine("Document converted with options successfully!");
+```
+
+### Step 6: Specifying Page Range for Conversion
+
+You can convert specific pages by specifying the starting page and the number of pages:
+
+#### Using C# SDK
+
+```csharp
+// Open the file
+var fileStream = File.Open("C:\\path\\to\\multipage.docx", FileMode.Open);
+
+// Create the request with page range parameters
+// Start from page 2 and convert 3 pages
+var request = new ConvertDocumentDirectRequest("pdf", fileStream, 2, 3);
+
+// Execute the API call
+var response = apiInstance.ConvertDocumentDirect(request);
+
+// Save the result to a file
+using (var outputStream = File.Create("C:\\path\\to\\specific_pages.pdf"))
+{
+ response.CopyTo(outputStream);
+}
+
+Console.WriteLine("Specific pages converted successfully!");
+```
+
+### Step 7: Complete Implementation Example
+
+Here's a complete example that demonstrates direct document conversion in C#:
+
+```csharp
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-dotnet-samples
+using System;
+using System.IO;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace DirectDocumentConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Get your client ID and client secret from https://dashboard.groupdocs.cloud
+ string MyClientSecret = "YOUR_CLIENT_SECRET";
+ string MyClientId = "YOUR_CLIENT_ID";
+
+ // Create API instance
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+ var apiInstance = new ConvertApi(configuration);
+
+ try
+ {
+ // Path to local file
+ string filePath = @"C:\Documents\sample.docx";
+
+ Console.WriteLine("Converting document directly...");
+
+ // Open the file stream
+ using (var fileStream = File.OpenRead(filePath))
+ {
+ // For password-protected files
+ var loadOptions = new DocxLoadOptions
+ {
+ Format = "docx",
+ Password = "your-password" // Remove if not needed
+ };
+
+ // Create conversion options
+ var convertOptions = new PdfConvertOptions
+ {
+ Dpi = 300,
+ Grayscale = false
+ };
+
+ // Create the request
+ var request = new ConvertDocumentDirectRequest(
+ "pdf",
+ fileStream,
+ null, // fromPage - null for all pages
+ null, // pagesCount - null for all pages
+ loadOptions,
+ convertOptions);
+
+ // Execute conversion
+ var result = apiInstance.ConvertDocumentDirect(request);
+
+ // Save the result
+ string outputPath = @"C:\Documents\sample_converted.pdf";
+ using (var outputStream = File.Create(outputPath))
+ {
+ result.CopyTo(outputStream);
+ }
+
+ Console.WriteLine($"Document converted successfully and saved to {outputPath}");
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error during conversion: " + e.Message);
+ }
+
+ Console.WriteLine("Press any key to exit.");
+ Console.ReadKey();
+ }
+ }
+}
+```
+
+## SDK Examples for Other Languages
+
+### Java Example
+
+```java
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-java-samples
+String MyClientSecret = ""; // Get from https://dashboard.groupdocs.cloud
+String MyClientId = ""; // Get from https://dashboard.groupdocs.cloud
+
+Configuration configuration = new Configuration(MyClientId, MyClientSecret);
+
+// Create API instance
+ConvertApi apiInstance = new ConvertApi(configuration);
+
+File file = new File("examples\\src\\main\\resources\\WordProcessing\\password-protected.docx");
+DocxLoadOptions loadOptions = new DocxLoadOptions();
+loadOptions.setFormat("docx");
+loadOptions.setPassword("password");
+
+ConvertDocumentDirectRequest request = new ConvertDocumentDirectRequest("pdf", file, 1, 0, loadOptions, null); // all pages
+
+File result = apiInstance.convertDocumentDirect(request);
+
+System.out.println("Document converted: " + result.length());
+```
+
+### Node.js Example
+
+```javascript
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-node-samples
+global.conversion_cloud = require("groupdocs-conversion-cloud");
+
+global.clientId = "XXXX-XXXX-XXXX-XXXX"; // Get ClientId and ClientSecret from https://dashboard.groupdocs.cloud
+global.clientSecret = "XXXXXXXXXXXXXXXX"; // Get ClientId and ClientSecret from https://dashboard.groupdocs.cloud
+
+global.convertApi = conversion_cloud.ConvertApi.fromKeys(clientId, clientSecret);
+
+let file = fs.readFileSync('./Resources/WordProcessing/password-protected.docx');
+let loadOptions = new conversion_cloud.DocxLoadOptions();
+loadOptions.format = "docx";
+loadOptions.password = "password";
+let request = new conversion_cloud.ConvertDocumentDirectRequest("pdf", file, undefined, undefined, loadOptions);
+
+let result = await convertApi.convertDocumentDirect(request);
+
+console.log("Document converted: " + result.length);
+```
+
+### Python Example
+
+```python
+# For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-python-samples
+import groupdocs_conversion_cloud
+
+client_id = "XXXX-XXXX-XXXX-XXXX" # Get ClientId and ClientSecret from https://dashboard.groupdocs.cloud
+client_secret = "XXXXXXXXXXXXXXXX" # Get ClientId and ClientSecret from https://dashboard.groupdocs.cloud
+
+# Create necessary API instances
+apiInstance = groupdocs_conversion_cloud.ConvertApi.from_keys(client_id, client_secret)
+
+# Prepare request
+load_options = groupdocs_conversion_cloud.DocxLoadOptions()
+load_options.format = "docx"
+load_options.password = "password"
+request = groupdocs_conversion_cloud.ConvertDocumentDirectRequest("pdf", "Resources\\WordProcessing\\password-protected.docx", None, None, load_options)
+
+# Convert
+result = apiInstance.convert_document_direct(request)
+
+print("Document converted: " + result)
+```
+
+## Troubleshooting Tips
+
+- File Not Found Errors: Ensure the local file path is correct and the file exists.
+- Authentication Issues: Verify your Client ID and Client Secret are correct.
+- Format Not Supported: Check if the conversion from your source format to the target format is supported.
+- Memory Issues: For large files, ensure your application has enough memory allocated.
+- Password Errors: For protected documents, double-check the password is correct.
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Convert documents directly without using cloud storage
+- Work with password-protected documents
+- Apply specific conversion options
+- Convert selected pages from a document
+- Implement direct conversion in various programming languages
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a simple web application that accepts file uploads and returns converted documents
+2. Build a conversion utility that supports batch direct conversion of multiple files
+3. Implement a solution that compares the performance of storage-based vs. direct conversion
+
+## Next Tutorial
+
+Continue your learning journey with our next tutorial: [Tutorial: How to Get Document Metadata](/quick-start-guide/document-metadata/) to learn how to retrieve and analyze document metadata.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We'd love to hear your feedback on this tutorial! Please feel free to ask questions or suggest improvements on our [support forum](https://forum.groupdocs.cloud/c/conversion/11).
+
diff --git a/content/conversion/english/quick-start-guide/convert-document/_index.md b/content/conversion/english/quick-start-guide/convert-document/_index.md
new file mode 100644
index 0000000..9255409
--- /dev/null
+++ b/content/conversion/english/quick-start-guide/convert-document/_index.md
@@ -0,0 +1,357 @@
+---
+title: How to Convert Documents with GroupDocs.Conversion Cloud Tutorial
+weight: 2
+description: Learn step-by-step how to convert documents between various formats using GroupDocs.Conversion Cloud API in this developer tutorial.
+url: /quick-start-guide/convert-document/
+---
+
+# Tutorial: How to Convert Documents with GroupDocs.Conversion Cloud
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- How to upload files to GroupDocs cloud storage
+- How to convert documents from one format to another using cloud storage
+- How to download the converted document
+- How to work with conversion options for different file formats
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (get a [free trial](https://dashboard.groupdocs.cloud/#/apps) if needed)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST APIs
+- Familiarity with your preferred programming language (C#, Java, PHP, etc.)
+- Completed our [Supported Formats tutorial](/quick-start-guide/supported-formats/) (recommended)
+
+## Why Use Document Conversion?
+
+Document conversion is essential for modern applications as it enables:
+- Standardization of document formats across an organization
+- Creation of archivable versions of documents (like PDF/A)
+- Improved document sharing and compatibility between different systems
+- Data extraction from proprietary formats for analysis
+
+## Tutorial Steps
+
+### Step 1: Understanding the Conversion Process
+
+The GroupDocs.Conversion Cloud API document conversion process involves three main steps:
+1. Upload the input document to cloud storage
+2. Convert the document to the desired format
+3. Download the converted document (optional if using output path)
+
+Let's implement each of these steps.
+
+### Step 2: Set Up Your Environment
+
+First, let's set up our development environment:
+
+#### Try it yourself:
+
+1. Create a new project in your preferred IDE
+2. Install the appropriate GroupDocs.Conversion Cloud SDK for your language
+3. Set up your authentication credentials:
+
+```csharp
+// C# example
+string MyClientSecret = ""; // Get from https://dashboard.groupdocs.cloud
+string MyClientId = ""; // Get from https://dashboard.groupdocs.cloud
+
+var configuration = new Configuration(MyClientId, MyClientSecret);
+
+// Create necessary API instances
+var convertApi = new ConvertApi(configuration);
+var storageApi = new StorageApi(configuration); // For uploading files
+```
+
+### Step 3: Upload a File to Cloud Storage
+
+Before conversion, we need to upload our file to the GroupDocs cloud storage:
+
+#### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=xxxx&client_secret=xxxx" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Upload file
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/storage/file/WordProcessing/four-pages.docx" \
+-X PUT \
+-H "Content-Type: application/octet-stream" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer " \
+--data-binary @"/path/to/local/four-pages.docx"
+```
+
+#### Using C# SDK
+
+```csharp
+using System.IO;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+// Upload file to cloud storage
+var uploadRequest = new UploadFileRequest("WordProcessing/four-pages.docx",
+ File.OpenRead("/path/to/local/four-pages.docx"), Common.MyStorage);
+storageApi.UploadFile(uploadRequest);
+
+Console.WriteLine("File uploaded successfully!");
+```
+
+### Step 4: Convert the Document
+
+Now, let's convert the uploaded document:
+
+#### Using cURL
+
+```bash
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/conversion" \
+-X POST \
+-H "Content-Type: application/json" \
+-H "Accept: application/json" \
+-H "Authorization: Bearer " \
+-d "{
+ 'FilePath': 'WordProcessing/four-pages.docx',
+ 'Format': 'pdf',
+ 'OutputPath': 'Output'
+ }"
+```
+
+#### Using C# SDK
+
+```csharp
+// Prepare convert settings
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ OutputPath = "converted"
+};
+
+// Convert to specified format
+var response = convertApi.ConvertDocument(new ConvertDocumentRequest(settings));
+
+Console.WriteLine("Document converted successfully!");
+foreach (var file in response)
+{
+ Console.WriteLine($"File: {file.Name}, Size: {file.Size}, Path: {file.Path}");
+}
+```
+
+### Step 5: Download the Converted Document
+
+After conversion, you can download the converted document:
+
+#### Using cURL
+
+```bash
+curl -v "https://api.groupdocs.cloud/v2.0/conversion/storage/file/Output/four-pages.pdf" \
+-X GET \
+-H "Accept: application/octet-stream" \
+-H "Authorization: Bearer " \
+--output "/path/to/local/four-pages.pdf"
+```
+
+#### Using C# SDK
+
+```csharp
+// Download converted file
+var downloadRequest = new DownloadFileRequest("converted/four-pages.pdf", Common.MyStorage);
+var stream = storageApi.DownloadFile(downloadRequest);
+
+// Save to local file
+using (var fileStream = File.Create("/path/to/save/four-pages.pdf"))
+{
+ stream.CopyTo(fileStream);
+}
+
+Console.WriteLine("File downloaded successfully!");
+```
+
+### Step 6: Working with Conversion Options
+
+Different formats have specific conversion options. Let's look at how to use PDF conversion options:
+
+#### Using C# SDK
+
+```csharp
+// Prepare convert settings with PDF options
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/four-pages.docx",
+ Format = "pdf",
+ OutputPath = "converted-with-options",
+ ConvertOptions = new PdfConvertOptions
+ {
+ CenterWindow = true,
+ CompressImages = false,
+ DisplayDocTitle = true,
+ Dpi = 1024,
+ FitWindow = false,
+ FromPage = 1,
+ Grayscale = false,
+ ImageQuality = 100,
+ Linearize = false,
+ MarginTop = 5,
+ MarginLeft = 5,
+ Password = "password", // Set password for the resulting PDF
+ UnembedFonts = true,
+ RemoveUnusedStreams = true,
+ RemoveUnusedObjects = true,
+ RemovePdfaCompliance = false
+ }
+};
+
+// Convert to PDF with options
+var response = convertApi.ConvertDocument(new ConvertDocumentRequest(settings));
+
+Console.WriteLine("Document converted with options successfully!");
+```
+
+### Step 7: Converting Password-Protected Documents
+
+If you need to convert a password-protected document, you must provide the password in the loading options:
+
+#### Using C# SDK
+
+```csharp
+// Prepare convert settings for password-protected document
+var settings = new ConvertSettings
+{
+ FilePath = "WordProcessing/password-protected.docx",
+ Format = "pdf",
+ OutputPath = "converted-protected",
+ LoadOptions = new DocxLoadOptions
+ {
+ Password = "your-document-password" // Password to open the protected document
+ }
+};
+
+// Convert the password-protected document
+var response = convertApi.ConvertDocument(new ConvertDocumentRequest(settings));
+
+Console.WriteLine("Password-protected document converted successfully!");
+```
+
+## Complete Implementation Example
+
+Here's a complete example combining all the steps above in C#:
+
+```csharp
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-dotnet-samples
+using System;
+using System.IO;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace DocumentConversionTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Get your client ID and client secret from https://dashboard.groupdocs.cloud
+ string MyClientSecret = "YOUR_CLIENT_SECRET";
+ string MyClientId = "YOUR_CLIENT_ID";
+
+ // Create API instances
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+ var convertApi = new ConvertApi(configuration);
+ var storageApi = new StorageApi(configuration);
+
+ try
+ {
+ // Step 1: Upload file to cloud storage
+ string localFilePath = @"C:\Documents\sample.docx";
+ string cloudFilePath = "WordProcessing/sample.docx";
+
+ Console.WriteLine("Uploading file...");
+ using (var stream = File.OpenRead(localFilePath))
+ {
+ var uploadRequest = new UploadFileRequest(cloudFilePath, stream);
+ storageApi.UploadFile(uploadRequest);
+ }
+ Console.WriteLine("File uploaded successfully!");
+
+ // Step 2: Convert the document
+ Console.WriteLine("Converting document...");
+ var settings = new ConvertSettings
+ {
+ FilePath = cloudFilePath,
+ Format = "pdf",
+ OutputPath = "converted"
+ };
+
+ var response = convertApi.ConvertDocument(new ConvertDocumentRequest(settings));
+ Console.WriteLine("Document converted successfully!");
+
+ // Step 3: Download the converted document
+ Console.WriteLine("Downloading converted document...");
+ string convertedFilePath = response[0].Path;
+ string localSavePath = @"C:\Documents\sample_converted.pdf";
+
+ var downloadRequest = new DownloadFileRequest(convertedFilePath);
+ var stream = storageApi.DownloadFile(downloadRequest);
+
+ using (var fileStream = File.Create(localSavePath))
+ {
+ stream.CopyTo(fileStream);
+ }
+ Console.WriteLine($"File downloaded successfully to {localSavePath}!");
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+
+ Console.WriteLine("Press any key to exit.");
+ Console.ReadKey();
+ }
+ }
+}
+```
+
+## Troubleshooting Tips
+
+- File Not Found Errors: Ensure the file path in cloud storage is correct. Remember that files are case-sensitive.
+- Authentication Issues: Make sure your Client ID and Client Secret are correct and that you're generating a valid JWT token.
+- Format Not Supported: Check if the conversion from your source format to the target format is supported using the formats API.
+- Password Issues: If converting a protected document, ensure the password is correct.
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Upload documents to GroupDocs cloud storage
+- Convert documents from one format to another
+- Download converted documents
+- Work with conversion options for different formats
+- Convert password-protected documents
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a batch conversion utility that converts multiple files in a folder
+2. Build a simple web form that allows users to upload a document and choose the target format
+3. Experiment with different conversion options for various formats (PDF, DOCX, XLSX, etc.)
+
+## Next Tutorial
+
+Continue your learning journey with our next tutorial: [Tutorial: How to Convert Documents Without Storage](/quick-start-guide/convert-direct/) to learn a more streamlined approach for document conversion.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We'd love to hear your feedback on this tutorial! Please feel free to ask questions or suggest improvements on our [support forum](https://forum.groupdocs.cloud/c/conversion/11).
diff --git a/content/conversion/english/quick-start-guide/document-metadata/_index.md b/content/conversion/english/quick-start-guide/document-metadata/_index.md
new file mode 100644
index 0000000..758e6eb
--- /dev/null
+++ b/content/conversion/english/quick-start-guide/document-metadata/_index.md
@@ -0,0 +1,510 @@
+---
+title: How to Get Document Metadata with GroupDocs.Conversion Cloud Tutorial
+weight: 4
+description: Learn how to retrieve and analyze document metadata using GroupDocs.Conversion Cloud API in this step-by-step tutorial for developers.
+url: /quick-start-guide/document-metadata/
+---
+
+# Tutorial: How to Get Document Metadata with GroupDocs.Conversion Cloud
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- What document metadata is and why it's important
+- How to retrieve metadata from documents stored in the cloud
+- How to interpret and use metadata information
+- How to apply this knowledge in real-world scenarios
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (get a [free trial](https://dashboard.groupdocs.cloud/#/apps) if needed)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST APIs
+- Familiarity with your preferred programming language (C#, Java, PHP, etc.)
+- Completed our [Basic Document Conversion tutorial](/quick-start-guide/convert-document/) (recommended)
+
+## Why Access Document Metadata?
+
+Document metadata provides valuable information about a file, including:
+- Author and creation information
+- Page count and dimensions
+- Security settings (password protection)
+- File size and format details
+- Timestamps and version information
+
+This information is essential for:
+- Building document management systems
+- Pre-conversion validation
+- File cataloging and searching
+- Document filtering and organization
+- Security assessment
+
+## Tutorial Steps
+
+### Step 1: Understanding Document Metadata
+
+Document metadata is information about a document that isn't part of the content itself. Different document types have various metadata properties, but common ones include:
+
+- File type/format
+- Number of pages
+- Document dimensions
+- Creation and modification dates
+- Author information
+- File size
+- Security settings
+
+The GroupDocs.Conversion Cloud API allows you to retrieve this information easily from documents stored in your cloud storage.
+
+### Step 2: Set Up Your Environment
+
+Let's start by setting up our development environment:
+
+#### Try it yourself:
+
+1. Create a new project in your preferred IDE
+2. Install the appropriate GroupDocs.Conversion Cloud SDK for your language
+3. Set up your authentication credentials:
+
+```csharp
+// C# example
+string MyClientSecret = ""; // Get from https://dashboard.groupdocs.cloud
+string MyClientId = ""; // Get from https://dashboard.groupdocs.cloud
+
+var configuration = new Configuration(MyClientId, MyClientSecret);
+
+// Create necessary API instance
+var infoApi = new InfoApi(configuration);
+```
+
+### Step 3: Retrieve Document Metadata
+
+Now, let's retrieve metadata from a document in cloud storage:
+
+#### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=xxxx&client_secret=xxxx" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get document metadata
+curl -X GET "https://api.groupdocs.cloud/v2.0/conversion/info?FilePath=words/four-pages.docx" \
+-H "accept: application/json" \
+-H "authorization: Bearer [Access Token]"
+```
+
+#### Using C# SDK
+
+```csharp
+try
+{
+ // Create document metadata request
+ var request = new GetDocumentMetadataRequest
+ {
+ FilePath = "WordProcessing/four-pages.docx",
+ StorageName = "MyStorage" // Optional, default storage is used if not specified
+ };
+
+ // Execute request
+ var metadata = infoApi.GetDocumentMetadata(request);
+
+ // Display metadata information
+ Console.WriteLine($"File Type: {metadata.FileType}");
+ Console.WriteLine($"Page Count: {metadata.PageCount}");
+ Console.WriteLine($"File Size: {metadata.Size} bytes");
+ Console.WriteLine($"Created Date: {metadata.CreatedDate}");
+ Console.WriteLine($"Modified Date: {metadata.ModifiedDate}");
+ Console.WriteLine($"Is Password Protected: {metadata.IsPasswordProtected}");
+
+ // Display additional information if available
+ if (metadata.Width > 0 && metadata.Height > 0)
+ {
+ Console.WriteLine($"Dimensions: {metadata.Width} x {metadata.Height}");
+ }
+
+ if (!string.IsNullOrEmpty(metadata.Author))
+ {
+ Console.WriteLine($"Author: {metadata.Author}");
+ }
+
+ if (!string.IsNullOrEmpty(metadata.Title))
+ {
+ Console.WriteLine($"Title: {metadata.Title}");
+ }
+}
+catch (Exception e)
+{
+ Console.WriteLine("Error retrieving document metadata: " + e.Message);
+}
+```
+
+### Step 4: Working with Password-Protected Documents
+
+If you need to retrieve metadata from a password-protected document, you'll need to provide the password:
+
+#### Using C# SDK
+
+```csharp
+try
+{
+ // Create document metadata request with password
+ var request = new GetDocumentMetadataRequest
+ {
+ FilePath = "WordProcessing/password-protected.docx",
+ StorageName = "MyStorage",
+ Password = "your-document-password" // Add the document password
+ };
+
+ // Execute request
+ var metadata = infoApi.GetDocumentMetadata(request);
+
+ // Display metadata
+ Console.WriteLine($"Successfully accessed password-protected document");
+ Console.WriteLine($"File Type: {metadata.FileType}");
+ Console.WriteLine($"Page Count: {metadata.PageCount}");
+ // ... other metadata properties
+}
+catch (Exception e)
+{
+ Console.WriteLine("Error retrieving document metadata: " + e.Message);
+}
+```
+
+### Step 5: Practical Applications
+
+Now let's look at some practical applications of document metadata:
+
+#### Checking if Conversion is Needed
+
+```csharp
+///
+/// Determines if a document needs to be converted based on its type
+///
+bool NeedsConversion(string filePath, string targetFormat, string storageName = null)
+{
+ try
+ {
+ // Get metadata
+ var request = new GetDocumentMetadataRequest
+ {
+ FilePath = filePath,
+ StorageName = storageName
+ };
+
+ var metadata = infoApi.GetDocumentMetadata(request);
+
+ // Check if already in target format
+ return !metadata.FileType.Equals(targetFormat, StringComparison.OrdinalIgnoreCase);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error checking document: " + e.Message);
+ throw;
+ }
+}
+
+// Usage example
+if (NeedsConversion("documents/sample.docx", "docx"))
+{
+ Console.WriteLine("Document already in DOCX format, no conversion needed.");
+}
+else
+{
+ Console.WriteLine("Document needs conversion.");
+ // Perform conversion
+}
+```
+
+#### Pre-conversion Document Validation
+
+```csharp
+///
+/// Validates a document before conversion
+///
+bool ValidateDocumentForConversion(string filePath, string storageName = null)
+{
+ try
+ {
+ // Get metadata
+ var request = new GetDocumentMetadataRequest
+ {
+ FilePath = filePath,
+ StorageName = storageName
+ };
+
+ var metadata = infoApi.GetDocumentMetadata(request);
+
+ // Perform validation checks
+ bool isValid = true;
+
+ // Check if file is too large (e.g., over 10MB)
+ if (metadata.Size > 10 * 1024 * 1024)
+ {
+ Console.WriteLine("Warning: File is very large, conversion may take longer.");
+ // isValid = false; // Uncomment to fail validation for large files
+ }
+
+ // Check if file has too many pages (e.g., over 100 pages)
+ if (metadata.PageCount > 100)
+ {
+ Console.WriteLine("Warning: Document has many pages, conversion may take longer.");
+ // isValid = false; // Uncomment to fail validation for many pages
+ }
+
+ // Check if file is password protected
+ if (metadata.IsPasswordProtected)
+ {
+ Console.WriteLine("Error: File is password protected. Please provide a password.");
+ isValid = false;
+ }
+
+ return isValid;
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error validating document: " + e.Message);
+ return false;
+ }
+}
+
+// Usage example
+if (ValidateDocumentForConversion("documents/large-document.pdf"))
+{
+ Console.WriteLine("Document passed validation, proceeding with conversion.");
+ // Proceed with conversion
+}
+else
+{
+ Console.WriteLine("Document failed validation, conversion aborted.");
+}
+```
+
+### Step 6: Complete Implementation Example
+
+Here's a complete example that demonstrates retrieving and using document metadata in C#:
+
+```csharp
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-dotnet-samples
+using System;
+using GroupDocs.Conversion.Cloud.Sdk.Api;
+using GroupDocs.Conversion.Cloud.Sdk.Client;
+using GroupDocs.Conversion.Cloud.Sdk.Model;
+using GroupDocs.Conversion.Cloud.Sdk.Model.Requests;
+
+namespace DocumentMetadataTutorial
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // Get your client ID and client secret from https://dashboard.groupdocs.cloud
+ string MyClientSecret = "YOUR_CLIENT_SECRET";
+ string MyClientId = "YOUR_CLIENT_ID";
+
+ // Create API instances
+ var configuration = new Configuration(MyClientId, MyClientSecret);
+ var infoApi = new InfoApi(configuration);
+ var storageApi = new StorageApi(configuration);
+ var convertApi = new ConvertApi(configuration);
+
+ try
+ {
+ // Define document path in cloud storage
+ string filePath = "WordProcessing/four-pages.docx";
+
+ Console.WriteLine("Retrieving document metadata...");
+
+ // Create metadata request
+ var request = new GetDocumentMetadataRequest
+ {
+ FilePath = filePath,
+ StorageName = "MyStorage" // Optional, default storage is used if not specified
+ };
+
+ // Execute request
+ var metadata = infoApi.GetDocumentMetadata(request);
+
+ // Display metadata information
+ Console.WriteLine("\nDocument Metadata:");
+ Console.WriteLine($"---------------------------");
+ Console.WriteLine($"File Type: {metadata.FileType}");
+ Console.WriteLine($"Page Count: {metadata.PageCount}");
+ Console.WriteLine($"File Size: {metadata.Size} bytes");
+ Console.WriteLine($"Created Date: {metadata.CreatedDate}");
+ Console.WriteLine($"Modified Date: {metadata.ModifiedDate}");
+ Console.WriteLine($"Is Password Protected: {metadata.IsPasswordProtected}");
+
+ // Display additional information if available
+ if (metadata.Width > 0 && metadata.Height > 0)
+ {
+ Console.WriteLine($"Dimensions: {metadata.Width} x {metadata.Height}");
+ }
+
+ if (!string.IsNullOrEmpty(metadata.Author))
+ {
+ Console.WriteLine($"Author: {metadata.Author}");
+ }
+
+ if (!string.IsNullOrEmpty(metadata.Title))
+ {
+ Console.WriteLine($"Title: {metadata.Title}");
+ }
+
+ // Demonstrate practical use of metadata
+ Console.WriteLine("\nPractical application example:");
+
+ // Check if PDF conversion is needed based on file type
+ if (metadata.FileType.Equals("pdf", StringComparison.OrdinalIgnoreCase))
+ {
+ Console.WriteLine("Document is already in PDF format, no conversion needed.");
+ }
+ else
+ {
+ Console.WriteLine("Document is not in PDF format, conversion would be required.");
+
+ // Check if document meets conversion requirements
+ if (metadata.IsPasswordProtected)
+ {
+ Console.WriteLine("Warning: Document is password protected. Password required for conversion.");
+ }
+
+ if (metadata.PageCount > 50)
+ {
+ Console.WriteLine("Note: Document has many pages, conversion may take longer.");
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error: " + e.Message);
+ }
+
+ Console.WriteLine("\nPress any key to exit.");
+ Console.ReadKey();
+ }
+ }
+}
+```
+
+## SDK Examples for Other Languages
+
+### Java Example
+
+```java
+// For complete examples and data files, please go to https://github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-java-samples
+InfoApi apiInstance = new InfoApi(Utils.AppSID, Utils.AppKey);
+try {
+ GetDocumentMetadataRequest request = new GetDocumentMetadataRequest();
+ request.setStorageName(Utils.MYStorage);
+ request.setFilePath("conversions/sample.docx");
+
+ DocumentMetadata response = apiInstance.getDocumentMetadata(request);
+
+ System.out.println("File Type: " + response.getFileType());
+ System.out.println("Page Count: " + response.getPageCount());
+ System.out.println("Size: " + response.getSize() + " bytes");
+ System.out.println("Created Date: " + response.getCreatedDate());
+} catch (ApiException e) {
+ System.err.println("Exception while calling InfoApi:");
+ e.printStackTrace();
+}
+```
+
+### PHP Example
+
+```php
+setStorageName(CommonUtils::$MyStorage);
+ $request->setFilePath("conversions/sample.docx");
+
+ $metadata = $infoApi->getDocumentMetadata($request);
+
+ echo "File Type: " . $metadata->getFileType() . "
";
+ echo "Page Count: " . $metadata->getPageCount() . "
";
+ echo "Size: " . $metadata->getSize() . " bytes
";
+ echo "Is Password Protected: " . ($metadata->getIsPasswordProtected() ? "Yes" : "No") . "
";
+} catch (Exception $e) {
+ echo "Something went wrong: " . $e->getMessage();
+}
+?>
+```
+
+### Python Example
+
+```python
+# Import modules
+import groupdocs_conversion_cloud
+from Common_Utilities.Utils import Common_Utilities
+
+# Create instance of the API
+api = Common_Utilities.Get_InfoApi_Instance()
+
+try:
+ request = groupdocs_conversion_cloud.GetDocumentMetadataRequest()
+ request.storage_name = Common_Utilities.myStorage
+ request.file_path = "conversions/sample.docx"
+
+ metadata = api.get_document_metadata(request)
+
+ print("Document Information:")
+ print(f"File Type: {metadata.file_type}")
+ print(f"Page Count: {metadata.page_count}")
+ print(f"Size: {metadata.size} bytes")
+ print(f"Created Date: {metadata.created_date}")
+ print(f"Is Password Protected: {metadata.is_password_protected}")
+
+except groupdocs_conversion_cloud.ApiException as e:
+ print("Exception while calling API: {0}".format(e.message))
+```
+
+## Troubleshooting Tips
+
+- File Not Found Errors: Ensure the file path in cloud storage is correct and the file exists.
+- Authentication Issues: Verify your Client ID and Client Secret are correct.
+- Permission Errors: Make sure your account has access to the specified storage.
+- Password Required: If you get an "invalid password" error, the document is password-protected. Provide the correct password in your request.
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Retrieve metadata from documents stored in GroupDocs cloud storage
+- Access key document properties like file type, page count, and security settings
+- Handle password-protected documents
+- Apply metadata information in practical scenarios like pre-conversion validation
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a document inventory tool that scans a folder in cloud storage and reports metadata for all documents
+2. Build a simple web interface that displays document metadata for uploaded files
+3. Implement a document filter that categorizes files by type, size, or page count based on metadata
+
+## Next Steps
+
+Congratulations! You've completed our Quick Start Guide tutorial series for GroupDocs.Conversion Cloud API. You now have the skills to:
+- Check supported document formats
+- Convert documents using cloud storage
+- Perform direct document conversions
+- Retrieve and utilize document metadata
+
+You're now ready to implement these features in your own applications!
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We'd love to hear your feedback on this tutorial series! Please feel free to ask questions or suggest improvements on our [support forum](https://forum.groupdocs.cloud/c/conversion/11).
diff --git a/content/conversion/english/quick-start-guide/supported-formats/_index.md b/content/conversion/english/quick-start-guide/supported-formats/_index.md
new file mode 100644
index 0000000..6fd785f
--- /dev/null
+++ b/content/conversion/english/quick-start-guide/supported-formats/_index.md
@@ -0,0 +1,228 @@
+---
+title: Learn About Supported File Formats in GroupDocs.Conversion Cloud Tutorial
+weight: 1
+description: Learn how to retrieve and work with supported file formats in GroupDocs.Conversion Cloud API in this step-by-step tutorial for developers.
+url: /quick-start-guide/supported-formats/
+---
+
+# Tutorial: Learn About Supported File Formats in GroupDocs.Conversion Cloud
+
+## Learning Objectives
+
+In this tutorial, you'll learn:
+- How to retrieve all supported file formats in GroupDocs.Conversion Cloud
+- How to get supported conversion formats for a specific file type
+- How to process and utilize the formats information in your applications
+
+## Prerequisites
+
+Before starting this tutorial, you should have:
+- A GroupDocs.Conversion Cloud account (get a [free trial](https://dashboard.groupdocs.cloud/#/apps) if needed)
+- Your Client ID and Client Secret credentials
+- Basic understanding of REST APIs
+- Familiarity with your preferred programming language (C#, Java, PHP, etc.)
+
+## Why Learn About Supported Formats?
+
+Before attempting any document conversion, it's essential to know which formats are supported by the API. This knowledge helps you:
+- Design appropriate file upload interfaces for your users
+- Implement proper validation for input files
+- Provide users with accurate conversion options
+
+## Tutorial Steps
+
+### Step 1: Set Up Your Environment
+
+First, let's set up our development environment and initialize the necessary components to work with the GroupDocs.Conversion Cloud API.
+
+#### Try it yourself:
+
+1. Create a new project in your preferred IDE
+2. Install the appropriate GroupDocs.Conversion Cloud SDK for your language:
+ - For .NET: `Install-Package GroupDocs.Conversion-Cloud`
+ - For Java: Add the dependency to your pom.xml
+ - For PHP: `composer require groupdocs-conversion-cloud/groupdocs-conversion-cloud-php`
+ - For Node.js: `npm install groupdocs-conversion-cloud`
+ - For Python: `pip install groupdocs-conversion-cloud`
+ - For Ruby: `gem install groupdocs_conversion_cloud`
+ - For Go: `go get github.com/groupdocs-conversion-cloud/groupdocs-conversion-cloud-go`
+
+3. Set up your authentication credentials:
+
+```csharp
+// C# example
+string MyClientSecret = ""; // Get from https://dashboard.groupdocs.cloud
+string MyClientId = ""; // Get from https://dashboard.groupdocs.cloud
+
+var configuration = new Configuration(MyClientId, MyClientSecret);
+var apiInstance = new InfoApi(configuration);
+```
+
+### Step 2: Retrieve All Supported File Formats
+
+Now, let's retrieve all the supported file formats from the API:
+
+#### Using cURL
+
+```bash
+# First get JSON Web Token
+curl -v "https://api.groupdocs.cloud/connect/token" \
+-X POST \
+-d "grant_type=client_credentials&client_id=xxxx&client_secret=xxxx" \
+-H "Content-Type: application/x-www-form-urlencoded" \
+-H "Accept: application/json"
+
+# Get supported formats
+curl -X GET "https://api.groupdocs.cloud/v2.0/conversion/formats" \
+-H "accept: application/json" \
+-H "authorization: Bearer [Access Token]"
+```
+
+#### Using C# SDK
+
+```csharp
+try
+{
+ // Get supported file formats
+ var response = apiInstance.GetSupportedConversionTypes(new GetSupportedConversionTypesRequest());
+
+ Console.WriteLine("Available conversion formats:");
+ foreach (var entry in response)
+ {
+ Console.WriteLine($"Source format: {entry.SourceFormat}");
+ Console.WriteLine($"Can be converted to: {string.Join(", ", entry.TargetFormats)}");
+ Console.WriteLine();
+ }
+}
+catch (Exception e)
+{
+ Console.WriteLine("Exception while calling InfoApi: " + e.Message);
+}
+```
+
+### Step 3: Get Supported Formats for a Specific File Type
+
+Sometimes you may need to know which formats a specific file type can be converted to:
+
+#### Using cURL
+
+```bash
+curl -X GET "https://api.groupdocs.cloud/v2.0/conversion/formats?format=docx" \
+-H "accept: application/json" \
+-H "authorization: Bearer [Access Token]"
+```
+
+#### Using C# SDK
+
+```csharp
+try
+{
+ // Get supported file formats for DOCX
+ var response = apiInstance.GetSupportedConversionTypes(
+ new GetSupportedConversionTypesRequest(null, null, "docx"));
+
+ foreach (var entry in response)
+ {
+ Console.WriteLine($"DOCX can be converted to: {string.Join(", ", entry.TargetFormats)}");
+ }
+}
+catch (Exception e)
+{
+ Console.WriteLine("Exception while calling InfoApi: " + e.Message);
+}
+```
+
+### Step 4: Get Supported Formats for a Specific Document
+
+You can also check which formats are supported for a specific document that's already in your storage:
+
+#### Using C# SDK
+
+```csharp
+try
+{
+ // Get supported file formats for a specific document in storage
+ var response = apiInstance.GetSupportedConversionTypes(
+ new GetSupportedConversionTypesRequest("conversions/sample.docx", "MyStorage"));
+
+ foreach (var entry in response)
+ {
+ Console.WriteLine($"The document can be converted to: {string.Join(", ", entry.TargetFormats)}");
+ }
+}
+catch (Exception e)
+{
+ Console.WriteLine("Exception while calling InfoApi: " + e.Message);
+}
+```
+
+### Step 5: Process and Utilize the Format Information
+
+Now that you have the format information, let's implement a practical example that builds a user interface to show available conversion options:
+
+```csharp
+// Example: Building a dropdown list of target formats for a given source format
+public List GetTargetFormatsForSourceFormat(string sourceFormat)
+{
+ try
+ {
+ var response = apiInstance.GetSupportedConversionTypes(
+ new GetSupportedConversionTypesRequest(null, null, sourceFormat));
+
+ if (response != null && response.Count > 0)
+ {
+ return response[0].TargetFormats.ToList();
+ }
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("Error getting formats: " + e.Message);
+ }
+
+ return new List();
+}
+
+// Usage example
+var pdfTargetFormats = GetTargetFormatsForSourceFormat("pdf");
+Console.WriteLine("PDF can be converted to these formats:");
+foreach (var format in pdfTargetFormats)
+{
+ Console.WriteLine($" - {format}");
+}
+```
+
+## Troubleshooting Tips
+
+- Authentication Errors: Make sure your Client ID and Client Secret are correct and that you're generating a valid JWT token.
+- Empty Results: If you get empty results for a specific format, check if the format name is spelled correctly (e.g., "xlsx" not "excel").
+- API Connection Issues: Ensure your network allows outbound connections to the GroupDocs API endpoints.
+
+## What You've Learned
+
+In this tutorial, you've learned how to:
+- Set up your environment to work with GroupDocs.Conversion Cloud API
+- Retrieve all supported file formats
+- Get conversion options for specific file types
+- Get conversion options for documents already in storage
+- Process and utilize the format information in your applications
+
+## Further Practice
+
+To reinforce your learning, try these exercises:
+1. Create a simple web form that dynamically updates the target format dropdown based on the selected source format.
+2. Implement a function that checks if a specific conversion path is supported (e.g., DOCX → PDF).
+3. Build a utility that validates user uploads against supported formats.
+
+## Next Tutorial
+
+Now that you understand the supported formats, proceed to our next tutorial: [Tutorial: How to Convert Documents](/quick-start-guide/convert-document) to learn how to actually perform conversions.
+
+## Helpful Resources
+
+- [Product Page](https://products.groupdocs.cloud/conversion/)
+- [Documentation](https://docs.groupdocs.cloud/conversion/)
+- [API Reference](https://reference.groupdocs.cloud/conversion/)
+- [Free Support](https://forum.groupdocs.cloud/c/conversion/11)
+- [Free Trial](https://dashboard.groupdocs.cloud/#/apps)
+
+We'd love to hear your feedback on this tutorial! Please feel free to ask questions or suggest improvements on our [support forum](https://forum.groupdocs.cloud/c/conversion/11).
diff --git a/content/home/english/_index.md b/content/home/english/_index.md
index 3a8ae16..0cff129 100644
--- a/content/home/english/_index.md
+++ b/content/home/english/_index.md
@@ -15,7 +15,7 @@ Welcome to our comprehensive collection of tutorials for all GroupDocs Cloud pro
### [GroupDocs.Viewer Cloud Tutorials](./viewer/)
Learn how to render and display over 170 document and image file formats in your applications without requiring additional software or plugins. Our tutorials cover rendering to HTML, PDF, and image formats with various customization options.
-### [GroupDocs.Conversion Cloud Tutorials](#)
+### [GroupDocs.Conversion Cloud Tutorials](./conversion/)
Master document conversion between multiple formats with our detailed guides. Learn to convert documents to and from PDF, Word, Excel, PowerPoint, images, and many other formats through simple API calls.
### [GroupDocs.Merger Cloud Tutorials](#)
diff --git a/content/viewer/english/data-structures/render-options/_index.md b/content/viewer/english/data-structures/render-options/_index.md
index fa39209..278f6a5 100644
--- a/content/viewer/english/data-structures/render-options/_index.md
+++ b/content/viewer/english/data-structures/render-options/_index.md
@@ -327,7 +327,7 @@ In this tutorial, you've mastered:
## Next Steps
-Ready to learn more about format-specific rendering? Continue your journey with our [HTML Rendering Tutorial](/data-structures/htmloptions) or [Image Rendering Tutorial](/data-structures/image-options/).
+Ready to learn more about format-specific rendering? Continue your journey with our [HTML Rendering Tutorial](/data-structures/html-options/) or [Image Rendering Tutorial](/data-structures/image-options/).
## Helpful Resources