Build a Custom Report

POST https://api.copyleaks.com/v3/downloads/my-scan-1/export/my-export-1

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

Body
{
  "completionWebhook": "https://your-server.com/webhook/export/my-export-1/completed",
  "maxRetries": 3,
  "crawledVersion": {
    "endpoint": "https://your-server.com/webhook/export/my-export-1/crawled-version",
    "verb": "POST"
  },
  "results": [
    {
      "id": "2a1b402420",
      "endpoint": "https://your-server.com/webhook/export/my-export-1/results/2a1b402420",
      "verb": "POST"
    }
  ]
}

curl -X POST "https://api.copyleaks.com/v3/downloads/my-scan-1/export/my-export-1" \
     -H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
     -H "Content-Type: application/json" \
     -d '{
           "completionWebhook": "https://your-server.com/webhook/export/my-export-1/completed",
           "maxRetries": 3,
           "crawledVersion": {
             "endpoint": "https://your-server.com/webhook/export/my-export-1/crawled-version",
             "verb": "POST"
           },
           "results": [
             {
               "id": "2a1b402420",
               "endpoint": "https://your-server.com/webhook/export/my-export-1/results/2a1b402420",
               "verb": "POST"
             }
           ]
         }'

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

auth_token = Copyleaks.login("[email protected]", "YOUR_API_KEY")

scan_id = "my-scan-1"
export_id = "my-export-1"
base_url = f"https://your-server.com/webhook/export/{export_id}"
result_ids = ["2a1b402420"]  # every result ID from the completed webhook

export = Export()
export.set_completion_webhook(f"{base_url}/completed")

crawled = ExportCrawledVersion()
crawled.set_endpoint(f"{base_url}/crawled-version")
crawled.set_verb("POST")
export.set_crawled_version(crawled)

results = []
for result_id in result_ids:
    result = ExportResult()
    result.set_id(result_id)
    result.set_endpoint(f"{base_url}/results/{result_id}")
    result.set_verb("POST")
    results.append(result)
export.set_results(results)

Copyleaks.export(auth_token, scan_id, export_id, export)

const { Copyleaks, CopyleaksExportModel } = require('copyleaks');

async function exportForReport() {
  const copyleaks = new Copyleaks();
  const loginResult = await copyleaks.loginAsync('[email protected]', 'YOUR_API_KEY');

  const scanId = 'my-scan-1';
  const exportId = 'my-export-1';
  const baseUrl = `https://your-server.com/webhook/export/${exportId}`;
  const resultIds = ['2a1b402420']; // every result ID from the completed webhook

  const exportModel = new CopyleaksExportModel(
    `${baseUrl}/completed`,
    resultIds.map(id => ({ id, endpoint: `${baseUrl}/results/${id}`, verb: 'POST' })),
    { endpoint: `${baseUrl}/crawled-version`, verb: 'POST' }
  );

  await copyleaks.exportAsync(loginResult, scanId, exportId, exportModel);
}

exportForReport();

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

CopyleaksAuthToken authToken = Copyleaks.login("[email protected]", "YOUR_API_KEY");

String scanId = "my-scan-1";
String exportId = "my-export-1";
String baseUrl = "https://your-server.com/webhook/export/" + exportId;
String[] resultIds = { "2a1b402420" }; // every result ID from the completed webhook

ExportResults[] results = new ExportResults[resultIds.length];
for (int i = 0; i < resultIds.length; i++) {
    results[i] = new ExportResults(resultIds[i], baseUrl + "/results/" + resultIds[i], "POST", null);
}

ExportCrawledVersion crawledVersion = new ExportCrawledVersion(baseUrl + "/crawled-version", "POST", null);

CopyleaksExportModel exportModel = new CopyleaksExportModel(baseUrl + "/completed", results, crawledVersion);
Copyleaks.export(authToken, scanId, exportId, exportModel);

// Where matches overlap, the strongest type wins.
const PRIORITY = { identical: 3, minorChanges: 2, relatedMeaning: 1 };

// side "source" points into the crawled version's text.value,
// side "suspected" into the result's own text.value.
function collectRanges(result, side) {
  const ranges = [];
  for (const type of Object.keys(PRIORITY)) {
    const { starts, lengths } = result.text.comparison[type][side].chars;
    starts.forEach((start, i) => ranges.push({ start, end: start + lengths[i], type }));
  }
  return ranges;
}

// Split the text into runs that share the same highlight (or none).
function toSegments(text, ranges) {
  const marks = new Array(text.length).fill(null);
  for (const { start, end, type } of ranges) {
    for (let i = start; i < Math.min(end, text.length); i++) {
      if (!marks[i] || (PRIORITY[type] ?? 0) > (PRIORITY[marks[i]] ?? 0)) marks[i] = type;
    }
  }
  const segments = [];
  let from = 0;
  for (let i = 1; i <= text.length; i++) {
    if (i === text.length || marks[i] !== marks[from]) {
      segments.push({ text: text.slice(from, i), type: marks[from] });
      from = i;
    }
  }
  return segments;
}

# Where matches overlap, the strongest type wins.
PRIORITY = {"identical": 3, "minorChanges": 2, "relatedMeaning": 1}


def collect_ranges(result, side):
    """side="source" points into the crawled version's text.value,
    side="suspected" into the result's own text.value."""
    ranges = []
    for match_type in PRIORITY:
        chars = result["text"]["comparison"][match_type][side]["chars"]
        for start, length in zip(chars["starts"], chars["lengths"]):
            ranges.append((start, start + length, match_type))
    return ranges


def to_segments(text, ranges):
    """Split the text into runs that share the same highlight (or none).
    Positions count UTF-16 code units, so work on the UTF-16 encoding of the text."""
    units = text.encode("utf-16-le", "surrogatepass")
    size = len(units) // 2
    marks = [None] * size
    for start, end, match_type in ranges:
        for i in range(start, min(end, size)):
            if marks[i] is None or PRIORITY.get(match_type, 0) > PRIORITY.get(marks[i], 0):
                marks[i] = match_type
    segments, begin = [], 0
    for i in range(1, size + 1):
        if i == size or marks[i] != marks[begin]:
            segments.append((units[2 * begin:2 * i].decode("utf-16-le", "surrogatepass"), marks[begin]))
            begin = i
    return segments

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

// Uses records, so it needs Java 16 or later.
public class ReportHighlighter {
    // Where matches overlap, the strongest type wins.
    static final Map<String, Integer> PRIORITY =
            Map.of("identical", 3, "minorChanges", 2, "relatedMeaning", 1);

    record Range(int start, int end, String type) {}
    record Segment(String text, String type) {}

    // side "source" points into the crawled version's text.value,
    // side "suspected" into the result's own text.value.
    static List<Range> collectRanges(JsonObject result, String side) {
        List<Range> ranges = new ArrayList<>();
        JsonObject comparison = result.getAsJsonObject("text").getAsJsonObject("comparison");
        for (String type : PRIORITY.keySet()) {
            JsonObject chars = comparison.getAsJsonObject(type).getAsJsonObject(side).getAsJsonObject("chars");
            JsonArray starts = chars.getAsJsonArray("starts");
            JsonArray lengths = chars.getAsJsonArray("lengths");
            for (int i = 0; i < starts.size(); i++) {
                int start = starts.get(i).getAsInt();
                ranges.add(new Range(start, start + lengths.get(i).getAsInt(), type));
            }
        }
        return ranges;
    }

    // Split the text into runs that share the same highlight (or none).
    static List<Segment> toSegments(String text, List<Range> ranges) {
        String[] marks = new String[text.length()];
        for (Range r : ranges) {
            for (int i = r.start(); i < Math.min(r.end(), text.length()); i++) {
                if (marks[i] == null
                        || PRIORITY.getOrDefault(r.type(), 0) > PRIORITY.getOrDefault(marks[i], 0)) {
                    marks[i] = r.type();
                }
            }
        }
        List<Segment> segments = new ArrayList<>();
        int from = 0;
        for (int i = 1; i <= text.length(); i++) {
            if (i == text.length() || !Objects.equals(marks[i], marks[from])) {
                segments.add(new Segment(text.substring(from, i), marks[from]));
                from = i;
            }
        }
        return segments;
    }
}

function collectAiRanges(aiDetection) {
  const ranges = [];
  for (const section of aiDetection.results) {
    if (section.classification !== 2) continue; // 2 = AI-generated, 1 = human-written
    for (const match of section.matches) {
      const { starts, lengths } = match.text.chars;
      starts.forEach((start, i) => ranges.push({ start, end: start + lengths[i], type: 'ai' }));
    }
  }
  return ranges;
}

def collect_ai_ranges(ai_detection):
    ranges = []
    for section in ai_detection["results"]:
        if section["classification"] != 2:  # 2 = AI-generated, 1 = human-written
            continue
        for match in section["matches"]:
            chars = match["text"]["chars"]
            for start, length in zip(chars["starts"], chars["lengths"]):
                ranges.append((start, start + length, "ai"))
    return ranges

// Add to ReportHighlighter, and import com.google.gson.JsonElement
static List<Range> collectAiRanges(JsonObject aiDetection) {
    List<Range> ranges = new ArrayList<>();
    for (JsonElement element : aiDetection.getAsJsonArray("results")) {
        JsonObject section = element.getAsJsonObject();
        if (section.get("classification").getAsInt() != 2) continue; // 2 = AI-generated, 1 = human-written
        for (JsonElement match : section.getAsJsonArray("matches")) {
            JsonObject chars = match.getAsJsonObject().getAsJsonObject("text").getAsJsonObject("chars");
            JsonArray starts = chars.getAsJsonArray("starts");
            JsonArray lengths = chars.getAsJsonArray("lengths");
            for (int i = 0; i < starts.size(); i++) {
                int start = starts.get(i).getAsInt();
                ranges.add(new Range(start, start + lengths.get(i).getAsInt(), "ai"));
            }
        }
    }
    return ranges;
}