Export PDF Report

# macOS
brew install curl

# Ubuntu/Debian
sudo apt-get install curl

# Windows - download from https://curl.se

pip install copyleaks

npm install plagiarism-checker

Install-Package Copyleaks

composer require copyleaks/php-plagiarism-checker

gem install plagiarism-checker

<!-- Add to your pom.xml (requires Java 11+) -->
<dependency>
    <groupId>com.copyleaks.sdk</groupId>
    <artifactId>copyleaks-java-sdk</artifactId>
    <version>5.1.0</version>
</dependency>

POST https://id.copyleaks.com/v3/account/login/api
Content-Type: application/json

{
    "email": "<EMAIL_ADDRESS>",
    "key": "<API_KEY>"
}

curl -X POST "https://id.copyleaks.com/v3/account/login/api" \
     -H "Content-Type: application/json" \
     -d '{
           "email": "<EMAIL_ADDRESS>",
           "key": "<API_KEY>"
         }'

from copyleaks.copyleaks import Copyleaks
from copyleaks.exceptions.command_error import CommandError
from copyleaks.models.submit.document import FileDocument
from copyleaks.models.submit.properties.scan_properties import ScanProperties
from copyleaks.models.export import Export, ExportCrawledVersion, ExportResult, ExportPDF
import base64
import random

EMAIL_ADDRESS = "<EMAIL_ADDRESS>"
API_KEY = "<API_KEY>"

# Login to Copyleaks
try:
    auth_token = Copyleaks.login(EMAIL_ADDRESS, API_KEY)
except CommandError as ce:
    response = ce.get_response()
    print(f"An error occurred (HTTP status code {response.status_code}):")
    print(response.content)
    exit(1)

print("Logged successfully!\nToken:")
print(auth_token)

const copyleaks = require('copyleaks');

const EMAIL_ADDRESS = "<EMAIL_ADDRESS>";
const API_KEY = "<API_KEY>";

// Login to Copyleaks
const login = async () => {
    try {
        const authToken = await copyleaks.login(EMAIL_ADDRESS, API_KEY);
        console.log('Logged successfully!\nToken:', authToken);
        return authToken;
    } catch (error) {
        console.error('Failed to login:', error);
        process.exit(1);
    }
};

import com.copyleaks.sdk.api.Copyleaks;
import com.copyleaks.sdk.api.exceptions.CommandException;
import com.copyleaks.sdk.api.models.ScanProperties;
import com.copyleaks.sdk.api.models.FileSubmission;
import com.copyleaks.sdk.api.models.Export;
import com.copyleaks.sdk.api.models.ExportCrawledVersion;
import com.copyleaks.sdk.api.models.ExportResult;
import com.copyleaks.sdk.api.models.ExportPDF;
import java.util.Base64;
import java.util.Arrays;

String EMAIL_ADDRESS = "<EMAIL_ADDRESS>";
String API_KEY = "<API_KEY>";

// Login to Copyleaks
try {
    String authToken = Copyleaks.login(EMAIL_ADDRESS, API_KEY);
    System.out.println("Logged successfully!\nToken: " + authToken);
} catch (CommandException e) {
    System.out.println("Failed to login: " + e.getMessage());
    System.exit(1);
}

PUT https://api.copyleaks.com/v3/scans/submit/file/<SCAN_ID>
Authorization: Bearer <your_token>
Content-Type: application/json

{
    "base64": "<base64_encoded_file_content>",
    "filename": "<FILE_NAME>",
    "properties": {
        "webhooks": { "status": "https://your.server/webhook?event={\{STATUS\}}" },
        "sandbox": true,
        "pdf": {
            "create": true,
            "reportVersion": "v3",
            "title": "Custom PDF Report Title",
            "largeLogo": "<base64_encoded_logo>"
        }
    }
}

curl -X PUT "https://api.copyleaks.com/v3/scans/submit/file/<SCAN_ID>" \
     -H "Authorization: Bearer <your_token>" \
     -H "Content-Type: application/json" \
     -d '{
           "base64": "<base64_encoded_file_content>",
           "filename": "<FILE_NAME>",
           "properties": {
               "webhooks": { "status": "https://your.server/webhook?event={\{STATUS\}}" },
               "sandbox": true,
               "pdf": {
                   "create": true,
                   "reportVersion": "v3",
                   "title": "Custom PDF Report Title",
                   "largeLogo": "<base64_encoded_logo>"
               }
           }
         }'

# Submit a file for scanning with PDF generation enabled
scan_id = "<SCAN_ID>";
file_name = "<FILE_NAME>"
base64_file_content = base64.b64encode(b'Hello world.').decode('utf8')  # or read your file and convert it into BASE64 presentation.
print("Submitting a new file...")
file_submission = FileDocument(base64_file_content, file_name)

# Set scan properties with PDF options
scan_properties = ScanProperties('https://your.server/webhook?event={\{STATUS\}}')
scan_properties.set_sandbox(True)  # Turn on sandbox mode. Turn off on production.

# Enable PDF report generation
scan_properties.set_pdf({
    "create": True,
    "reportVersion": "v3",
    "title": "Custom PDF Report Title"
    # Add base64_logo if needed
})

file_submission.set_properties(scan_properties)

# Submit the file for scanning
Copyleaks.submit_file(auth_token, scan_id, file_submission)
print("Sent to scanning with PDF report enabled")
print("You will be notified, using your webhook, once the scan is completed.")

// Submit a file for scanning with PDF report enabled
const scanId = "<SCAN_ID>"; // Replace with your unique scan ID
const filename = "<FILE_NAME>";
const fileContent = Buffer.from('Hello world').toString('base64'); // Convert file content to base64

const submitFile = async (authToken) => {
    const scanProperties = new copyleaks.ScanProperties('https://your.server/webhook?event={\{STATUS\}}');
    scanProperties.setSandbox(true); // Enable sandbox mode for testing

    // Enable PDF report generation
    scanProperties.setPDF({
        create: true,
        reportVersion: "v3",
        title: "Custom PDF Report Title"
        // Add largeLogo if needed
    });

    const fileSubmission = new copyleaks.FileSubmission(fileContent, filename);
    fileSubmission.setProperties(scanProperties);

    try {
        await copyleaks.submitFile(authToken, scanId, fileSubmission);
        console.log('File submitted for scanning with PDF report enabled. Scan ID:', scanId);
    } catch (error) {
        console.error('Failed to submit file:', error);
    }
};

// Submit a file for scanning with PDF report enabled
String scanId = "<SCAN_ID>"; // Replace with your unique scan ID
String filename = "<FILE_NAME>";
String fileContent = Base64.getEncoder().encodeToString("Hello world".getBytes()); // Convert file content to base64

ScanProperties scanProperties = new ScanProperties("https://your.server/webhook?event={\{STATUS\}}");
scanProperties.setSandbox(true); // Enable sandbox mode for testing

// Enable PDF report generation
Map<String, Object> pdfProperties = new HashMap<>();
pdfProperties.put("create", true);
pdfProperties.put("reportVersion", "v3");
pdfProperties.put("title", "Custom PDF Report Title");
// Add largeLogo if needed
scanProperties.setPDF(pdfProperties);

FileSubmission fileSubmission = new FileSubmission(fileContent, filename);
fileSubmission.setProperties(scanProperties);

try {
    Copyleaks.submitFile(authToken, scanId, fileSubmission);
    System.out.println("File submitted for scanning with PDF report enabled. Scan ID: " + scanId);
} catch (CommandException e) {
    System.out.println("Failed to submit file: " + e.getMessage());
}

POST https://api.copyleaks.com/v3/downloads/<SCAN_ID>/export/<EXPORT_ID>
Authorization: Bearer <API_TOKEN>
Content-Type: application/json

{
    "completionWebhook": "https://your.server/webhook/export/completion",
    "pdf": {
        "endpoint": "https://your.server/webhook/export/pdf",
        "verb": "POST",
        "headers": {
            "key": "value",
            "key2": "value2"
        }
    }
}

curl -X POST "https://api.copyleaks.com/v3/downloads/<SCAN_ID>/export/<EXPORT_ID>" \
     -H "Authorization: Bearer <API_TOKEN>" \
     -H "Content-Type: application/json" \
     -d '{
           "completionWebhook": "https://your.server/webhook/export/completion",
           "pdf": {
               "endpoint": "https://your.server/webhook/export/pdf",
               "verb": "POST",
               "headers": {
                   "key": "value",
                   "key2": "value2"
               }
           }
         }'

# Export scan results including PDF report
export_id = "<EXPORT_ID>"
export = Export()
export.set_completion_webhook('https://your.server/webhook/export/completion')

# Export PDF report
pdf_export = ExportPDF()
pdf_export.set_endpoint('https://your.server/webhook/export/pdf')
pdf_export.set_verb('POST')
pdf_export.set_headers([['key', 'value'], ['key2', 'value2']])  # optional
export.set_pdf(pdf_export)

# Trigger the export
Copyleaks.export(auth_token, scan_id, export_id, export)
print("Export initiated. You will be notified via webhook once the export is completed.")

// Export scan results including PDF report
const exportId = '<EXPORT_ID>';
const exportResults = async (authToken, scanId) => {
    const exportRequest = new copyleaks.Export();
    exportRequest.setCompletionWebhook('https://your.server/webhook/export/completion');

    // Export PDF report
    const pdfExport = new copyleaks.ExportPDF();
    pdfExport.setEndpoint('https://your.server/webhook/export/pdf');
    pdfExport.setVerb('POST');
    exportRequest.setPDF(pdfExport);

    try {
        await copyleaks.export(authToken, scanId, exportId, exportRequest);
        console.log('Export initiated with PDF report. Export ID:', exportId);
    } catch (error) {
        console.error('Failed to export results:', error);
    }
};

// Export scan results including PDF report
String exportId = "<EXPORT_ID>";
Export exportRequest = new Export();
exportRequest.setCompletionWebhook("https://your.server/webhook/export/completion");

// Export PDF report
ExportPDF pdfExport = new ExportPDF();
pdfExport.setEndpoint("https://your.server/webhook/export/pdf");
pdfExport.setVerb("POST");
exportRequest.setPDF(pdfExport);

try {
    Copyleaks.export(authToken, scanId, exportId, exportRequest);
    System.out.println("Export initiated with PDF report. Export ID: " + exportId);
} catch (CommandException e) {
    System.out.println("Failed to export results: " + e.getMessage());
}