Detect Plagiarism in Code

# 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

Headers
Content-Type: application/json

Body
{
    "email": "[email protected]",
    "key": "00000000-0000-0000-0000-000000000000"
}

export COPYLEAKS_EMAIL="[email protected]"
export COPYLEAKS_API_KEY="your-api-key-here"

curl --request POST \
  --url https://id.copyleaks.com/v3/account/login/api \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --data "{
    \"email\": \"${COPYLEAKS_EMAIL}\",
    \"key\": \"${COPYLEAKS_API_KEY}\"
  }"

from copyleaks.copyleaks import Copyleaks

EMAIL_ADDRESS = "[email protected]"
API_KEY = "your-api-key-here"

# Login to Copyleaks
auth_token = Copyleaks.login(EMAIL_ADDRESS, API_KEY)
print("Logged successfully!\nToken:", auth_token)

const { Copyleaks } = require("plagiarism-checker");

const EMAIL_ADDRESS = "[email protected]";
const API_KEY = "your-api-key-here";
const copyleaks = new Copyleaks();

// Login function
function loginToCopyleaks() {
  return copyleaks.loginAsync(EMAIL_ADDRESS, API_KEY).then(
    (loginResult) => {
      console.log("Login successful!");
      console.log("Access Token:", loginResult.access_token);
      return loginResult;
    },
    (err) => {
      console.error('Login failed:', err);
      throw err;
    }
  );
}

loginToCopyleaks();

import classes.Copyleaks;
import models.response.CopyleaksAuthToken;

String EMAIL_ADDRESS = "[email protected]";
String API_KEY = "00000000-0000-0000-0000-000000000000";

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

PUT https://api.copyleaks.com/v3/scans/submit/file/my-code-scan

Headers
Authorization: Bearer <YOUR_AUTH_TOKEN>
Content-Type: application/json

Body
{
    "base64": "ZGVmIGFkZChhLCBiKToKICAgIHJldHVybiBhICsgYgo=",
    "filename": "main.py",
    "properties": {
        "webhooks": {
            "status": "https://your-server.com/webhook/{STATUS}"
        },
        "sandbox": true,
        "sensitivityLevel": 3,
        "scanning": {
            "internet": true,
            "copyleaksDb": {
                "includeMySubmissions": true,
                "includeOthersSubmissions": true
            }
        },
        "filters": {
            "minCopiedWords": 10
        }
    }
}

# Encode the source file. Works on macOS and Linux.
BASE64_CONTENT=$(base64 < main.py | tr -d '\n')

curl -X PUT "https://api.copyleaks.com/v3/scans/submit/file/my-code-scan" \
     -H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
     -H "Content-Type: application/json" \
     -d "{
           \"base64\": \"${BASE64_CONTENT}\",
           \"filename\": \"main.py\",
           \"properties\": {
             \"webhooks\": {
               \"status\": \"https://your-server.com/webhook/{STATUS}\"
             },
             \"sandbox\": true,
             \"sensitivityLevel\": 3,
             \"scanning\": {
               \"internet\": true,
               \"copyleaksDb\": {
                 \"includeMySubmissions\": true,
                 \"includeOthersSubmissions\": true
               }
             },
             \"filters\": {
               \"minCopiedWords\": 10
             }
           }
         }"

import base64
from copyleaks.copyleaks import Copyleaks
from copyleaks.models.submit.document import FileDocument
from copyleaks.models.submit.properties.scan_properties import ScanProperties
from copyleaks.models.submit.properties.submit_webhooks import SubmitWebhooks

# Read the source file and encode it as Base64. Keep the real extension in the filename.
FILENAME = "main.py"
with open(FILENAME, "rb") as f:
    base64_content = base64.b64encode(f.read()).decode("utf-8")

# A scan ID you can map back to the file, for example a path-based one.
scan_id = "my-code-scan"
file_submission = FileDocument(base64_content, FILENAME)

# Copyleaks calls this webhook when the scan completes. The endpoint must be publicly reachable.
webhooks = SubmitWebhooks()
webhooks.set_status('https://your-server.com/webhook/{STATUS}')
webhooks.set_new_result('https://your-server.com/webhook/new-results')

scan_properties = ScanProperties(status_webhook='https://your-server.com/webhook/{STATUS}')
scan_properties.set_webhooks(webhooks)
scan_properties.set_sandbox(True)  # Turn on sandbox mode. Turn off on production.
file_submission.set_properties(scan_properties)

Copyleaks.submit_file(auth_token, scan_id, file_submission)
print("Sent to scanning")
print("You will be notified, using your webhook, once the scan is completed.")

const { Copyleaks, CopyleaksFileSubmissionModel } = require('plagiarism-checker');
const fs = require('fs');

async function submitCodeForPlagiarismCheck() {
    try {
        // Initialize Copyleaks
        const copyleaks = new Copyleaks();

        // Login to get the authentication token.
        // Replace with your email and API key.
        const loginResult = await copyleaks.loginAsync('[email protected]', 'YOUR_API_KEY');

        const scanId = `code-plagiarism-scan-${Date.now()}`;
        const WEBHOOK_URL = "https://your-server.com/webhook";

        // Read the source file and encode it as Base64. Keep the real extension in the filename.
        const filename = 'main.py';
        const base64Content = fs.readFileSync(filename).toString('base64');

        // Create a submission model
        const submission = new CopyleaksFileSubmissionModel(
            base64Content,
            filename,
            {
                sandbox: true, // Use sandbox for testing
                webhooks: {
                    // Copyleaks will notify this URL when the scan is complete.
                    status: `${WEBHOOK_URL}/{STATUS}`
                },
                sensitivityLevel: 3,
                scanning: {
                    internet: true,
                    copyleaksDb: {
                        includeMySubmissions: true,
                        includeOthersSubmissions: true
                    }
                },
                filters: {
                    // Skip very short matches such as import lines and license headers
                    minCopiedWords: 10
                }
            }
        );

        // Submit the file for scanning
        await copyleaks.submitFileAsync(loginResult, scanId, submission);
        console.log(`Submission successful. Scan ID: ${scanId}`);

    } catch (error) {
        console.error("An error occurred:", error);
    }
}

submitCodeForPlagiarismCheck();

import classes.Copyleaks;
import models.submissions.CopyleaksFileSubmissionModel;
import models.submissions.properties.*;
import java.util.Base64;
import java.nio.file.*;

String scanId = "my-code-scan";

// Read the source file and encode it as Base64. Keep the real extension in the filename.
String filename = "App.java";
String base64Content = Base64.getEncoder().encodeToString(Files.readAllBytes(Paths.get(filename)));

// Configure webhooks
SubmissionWebhooks webhooks = new SubmissionWebhooks("https://your-server.com/webhook/{STATUS}");
webhooks.setNewResult("https://your-server.com/webhook/new-results");

// Create submission properties
SubmissionProperties properties = new SubmissionProperties(webhooks);
properties.setSandbox(true); // Turn on sandbox mode. Turn off on production.

// Compare against online sources
SubmissionScanning scanning = new SubmissionScanning();
scanning.setInternet(true);
properties.setScanning(scanning);

// Optional: 1 (faster) to 5 (slower, more thorough)
properties.setSensitivityLevel(3);

// Create and submit the file
CopyleaksFileSubmissionModel submission = new CopyleaksFileSubmissionModel(base64Content, filename, properties);

Copyleaks.submitFile(authToken, scanId, submission);
System.out.println("Sent to scanning...");

POST https://api.copyleaks.com/v3/downloads/my-code-scan/export/<export_id>

Headers
Authorization: Bearer <your_token>
Content-Type: application/json

Body
{
    "completionWebhook":  "https://your-server.com/webhook/export/completion",
    "maxRetries": 3,
    "developerPayload": "custom_data_identifier",
    "crawledVersion": {
        "endpoint": "https://your-server.com/webhook/export/crawled",
        "verb": "POST",
        "headers": [
            [
                "header-key",
                "header-value"
            ]
        ]
    },
    "results": [
        {
            "id": "3f8a1c2d9e",
            "endpoint": "https://your-server.com/webhook/export/result/3f8a1c2d9e",
            "verb": "POST",
            "headers": [
                [
                    "header-key",
                    "header-value"
                ]
            ]
        }
    ]
}

curl -X POST "https://api.copyleaks.com/v3/downloads/my-code-scan/export/my-export-1" \
    -H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
    -H "Content-Type: application/json" \
    -d '{
          "completionWebhook": "https://your-server.com/webhook/export/completion",
          "maxRetries": 3,
          "developerPayload": "custom_data_identifier",
          "crawledVersion": {
              "endpoint": "https://your-server.com/webhook/export/crawled",
              "verb": "POST",
              "headers": {
                  "header-key": "header-value"
              }
          },
          "results": [
              {
                  "id": "<RESULT_ID_FROM_COMPLETED_WEBHOOK>",
                  "endpoint": "https://your-server.com/webhook/export/result/1",
                  "verb": "POST",
                  "headers": {
                      "header-key": "header-value"
                  }
              }
          ]
        }'

from copyleaks.copyleaks import Copyleaks
from copyleaks.models.export import Export, ExportResult

export_id = "my-export-1"
export = Export()
export.set_completion_webhook('https://your-server.com/webhook/export/completion')

# Export a specific plagiarism result
result1 = ExportResult()
result1.set_id('<RESULT_ID_FROM_COMPLETED_WEBHOOK>')
result1.set_endpoint('https://your-server.com/webhook/export/result/1')  # Only URL
result1.set_verb('POST')  # HTTP method separately
export.set_results([result1])

Copyleaks.export(auth_token, scan_id, export_id, export)
print("Export initiated.")

  const { Copyleaks, CopyleaksExportModel } = require('plagiarism-checker');

  async function exportPlagiarismResults() {
      try {
          // Initialize Copyleaks
          const copyleaks = new Copyleaks();

          // Login to get the authentication token.
          // Replace with your email and API key.
          const loginResult = await copyleaks.loginAsync('[email protected]', 'YOUR_API_KEY');

          const scanId = "my-code-scan"; // The ID of the scan you want to export
          const exportId = `export-${scanId}-${Date.now()}`;
          const WEBHOOK_URL = "https://your-server.com/webhook";

          // The result IDs to export, obtained from the completion webhook
          const resultIdsToExport = ["RESULT_ID_1", "RESULT_ID_2"];

          const results = resultIdsToExport.map(resultId => ({
              id: resultId,
              endpoint: `${WEBHOOK_URL}/export/${exportId}/result/${resultId}`,
              verb: "POST"
          }));

          // Create an export model
          const exportModel = new CopyleaksExportModel(
              `${WEBHOOK_URL}/export/${exportId}/completion`, // Completion webhook URL
              results,
              {
                  // Request to export the crawled version of the submitted file
                  endpoint: `${WEBHOOK_URL}/export/${exportId}/crawled-version`,
                  verb: "POST"
              }
          );

          // Start the export process
          await copyleaks.exportAsync(loginResult, scanId, exportId, exportModel);
          console.log(`Export initiated. Export ID: ${exportId}`);

      } catch (error) {
          console.error("An error occurred:", error);
      }
  }

  exportPlagiarismResults();

    import classes.Copyleaks;
    import models.exports.*;

    String scanId = "my-code-scan"; // Your scan ID from submission
    String exportId = "my-export-1"; // Your chosen export ID

    // Optional headers Copyleaks will send with each export webhook
    String[][] headers = new String[][]{
        new String[]{"header-key", "header-value"}
    };

    // Export a specific plagiarism result
    ExportResults results = new ExportResults(
        "3f8a1c2d9e", // Result ID from the completed webhook
        "https://your-server.com/webhook/export/result/3f8a1c2d9e", // Endpoint URL
        "POST", // HTTP method
        headers // Optional headers
    );

    ExportResults[] exportResultsArray = new ExportResults[]{ results };

    // Export the crawled version of the submitted file
    ExportCrawledVersion crawledVersion = new ExportCrawledVersion(
        "https://your-server.com/webhook/export/crawled",
        "POST",
        headers
    );

    // Create the export model
    CopyleaksExportModel exportModel = new CopyleaksExportModel(
        "https://your-server.com/webhook/export/completion", // Completion webhook
        exportResultsArray, // Results to export
        crawledVersion // Crawled version
    );

    try {
        Copyleaks.export(token, scanId, exportId, exportModel);
        System.out.println("Export initiated successfully.");
    } catch (Exception e) {
        System.out.println("Export failed: " + e.getMessage());
        e.printStackTrace();
    }