Copyleaks SDK

gem 'copyleaks'

copyleaks = Copyleaks::API.new(
  open_timeout: 10,       # seconds to connect (TCP and TLS)
  read_timeout: 120,      # seconds to wait for each read of a response
  write_timeout: 120,     # seconds to wait for each write of a request body (raise it for large uploads on slow links)
  keep_alive_timeout: 30, # seconds an idle connection is kept for reuse
  pool_size: 5            # maximum open connections per Copyleaks server
)

require 'copyleaks'
require 'base64'

# --- Your Credentials ---
USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
USER_API_KEY = 'YOUR_API_KEY'
# --------------------

begin
  # Log in to the Copyleaks API
  puts "Authenticating..."
  copyleaks = Copyleaks::API.new
  auth_token = copyleaks.login(USER_EMAIL, USER_API_KEY)
  puts "✅ Logged in successfully!"

end

require 'copyleaks'
require 'base64'

# --- Your Credentials ---
USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
USER_API_KEY = 'YOUR_API_KEY'
WEBHOOK_URL = 'https://your-server.com'
# --------------------

begin
    scanId = DateTime.now.strftime('%Q').to_s
    submisson = Copyleaks::CopyleaksFileSubmissionModel.new(
      'aGVsbG8gd29ybGQ=',
      'ruby.txt',
      Copyleaks::SubmissionProperties.new(
        Copyleaks::SubmissionWebhooks.new("#{WEBHOOK_URL}/webhook/{STATUS}","#{WEBHOOK_URL}/url-webhook/new-result"),
        true,
        'developer_payloads_test',
        true,
        60,
        1,
        true,
        Copyleaks::SubmissionActions::SCAN,
        Copyleaks::SubmissionAuthor.new('Author_name'),
        Copyleaks::SubmissionFilter.new(true, true, true),
        Copyleaks::SubmissionScanning.new(true, nil, nil, Copyleaks::SubmissionScanningCopyleaksDB.new(true, true)),
        Copyleaks::SubmissionIndexing.new([Copyleaks::SubmissionRepository.new('repo-1')]),
        Copyleaks::SubmissionExclude.new(true, true, true, true, true),
        Copyleaks::SubmissionPDF.new(true, 'pdf-title', BASE64_LOGO, false),
        Copyleaks::SubmissionSensitiveData.new(false)
      )
    )

    @copyleaks.submit_file(_authToken, scanId, submisson)

end

properties = Copyleaks::SubmissionProperties.new(
  Copyleaks::SubmissionWebhooks.new("#{WEBHOOK_URL}/webhook/{STATUS}"),
  nil, nil, true, # includeHtml, developerPayload, sandbox
  overview: Copyleaks::SubmissionOverview.new(true, ignoreAuthorData: true),       # Gen-AI Overview
  internalAiSourceMatch: Copyleaks::SubmissionInternalAiSourceMatch.new(true),     # Internal AI Source Match
  references: Copyleaks::SubmissionReferences.new(true),                           # Citation Checker
  scanTimeZone: 'America/New_York',                                                # time zone of the PDF report
  course: Copyleaks::SubmissionCourse.new('course-1'),
  assignment: Copyleaks::SubmissionAssignment.new('assignment-1'),
  institution: Copyleaks::SubmissionInstitution.new('institution-1')
)

model = Copyleaks::CopyleaksExportModel.new(
  'https://your-server.com/export/completed',
  nil,                                                                      # results
  nil,                                                                      # crawledVersion
  Copyleaks::ExportPdfReport.new('https://your-server.com/pdf', 'POST'),
  aiDetection: Copyleaks::ExportAiDetection.new('https://your-server.com/ai', 'POST'),
  writingFeedback: Copyleaks::ExportWritingFeedback.new('https://your-server.com/grammar', 'POST'),
  overview: Copyleaks::ExportOverview.new('https://your-server.com/overview', 'POST')
)
copyleaks.export(auth_token, scan_id, 'export-1', model)

require 'copyleaks'
require 'json'
require 'webrick'

# A WEBrick servlet, as in demo/webhookServer.rb. Mount it on your completed webhook URL:
#   server.mount '/webhook/completed', CompletedWebhookServlet
class CompletedWebhookServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_POST(req, res)
    payload = JSON.parse(req.body)
    completed = Copyleaks::CompletedWebhook.new(**payload.transform_keys(&:to_sym))

    alert = completed.ai_detection_alert # Copyleaks::Alerts, or nil when the scan produced no AI alert
    if alert
      begin
        # nil when the alert has no data; raises JSON::ParserError when additionalData is not valid JSON
        ai_result = alert.ai_detection_result
        if ai_result && ai_result.summary
          puts "AI: #{ai_result.summary.ai}, human: #{ai_result.summary.human}, model: #{ai_result.model_version}"
          Array(ai_result.results).each do |result|
            # classification: 1 = human, 2 = AI
            Array(result.matches).each do |match|
              puts "classification #{result.classification}: starts #{match.text.chars.starts.inspect}, lengths #{match.text.chars.lengths.inspect}"
            end
          end
        end
      rescue JSON::ParserError => e
        warn "Could not decode the AI alert: #{e.message}"
      end
    end

    # Acknowledge the webhook even when the AI alert could not be decoded.
    res.status = 200
  end
end

require 'copyleaks'
require 'base64'

# --- Your Credentials ---
USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
USER_API_KEY = 'YOUR_API_KEY'
# --------------------

begin
    scanId = DateTime.now.strftime('%Q').to_s
    text = "Lions are social animals, living in groups called prides, typically consisting of several females, their offspring, and a few males. Female lions are the primary hunters, working together to catch prey. Lions are known for their strength, teamwork, and complex social structures."
    submission = Copyleaks::NaturalLanguageSubmissionModel.new(
      text,
      nil,   # language: nil detects it automatically
      true,  # sandbox
      explain: true,  # AI Logic: the response includes the patterns behind the result
      sensitivity: 2  # 1 to 3
    )

    res = @copyleaks.ai_detection_client.submit_natural_language(_authToken, scanId, submission)
    result = Copyleaks::CopyleaksAiTextDetectionResponseModel.from_json(res)
    puts "AI: #{result.summary.ai}, human: #{result.summary.human}"

    # Credits available for AI Text Detection
    credits = @copyleaks.ai_detection_client.get_credits_balance(_authToken)['credits']

    # File types accepted by AI Text Detection (no login needed)
    file_types = @copyleaks.get_supported_ai_text_detection_file_types['supportedAiFileTypes']

end

require 'copyleaks'
require 'base64'

# --- Your Credentials ---
USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
USER_API_KEY = 'YOUR_API_KEY'
# --------------------

begin
 text = "Lions are the only cat that live in groups, called pride. A prides typically consists of a few adult males, several feales, and their offspring. This social structure is essential for hunting and raising young cubs. Female lions, or lionesses are the primary hunters of the prid. They work together in cordinated groups to take down prey usually targeting large herbiores like zbras, wildebeest and buffalo. Their teamwork and strategy during hunts highlight the intelligence and coperation that are key to their survival."
    scanId = DateTime.now.strftime('%Q').to_s
    score_weights = Copyleaks::ScoreWeights.new(0.1, 0.2, 0.3, 0.4)
    submission = Copyleaks::WritingAssistantSubmissionModel.new(
      text,
    )
    submission.sandbox = true
    submission.score = score_weights
    res = @copyleaks.writing_assistant_client.submit_text(_authToken, scanId, submission)

end

require 'copyleaks'
require 'base64'

# --- Your Credentials ---
USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
USER_API_KEY = 'YOUR_API_KEY'
# --------------------

begin
    scanId = DateTime.now.strftime('%Q').to_s
    labelsArray=[
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::ADULT_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::TOXIC_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::VIOLENT_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::PROFANITY_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::SELF_HARM_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::HARASSMENT_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::HATE_SPEECH_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::DRUGS_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::FIREARMS_V1),
      Copyleaks::CopyleaksTextModerationLabel.new(Copyleaks::CopyleaksTextModerationConstants::CYBERSECURITY_V1)
    ]
    
    text_moderation_request = Copyleaks::CopyleaksTextModerationRequestModel.new(
      text: "This is some text to scan.",
      sandbox: true,
      language: Copyleaks::CopyleaksTextModerationLanguages::ENGLISH,
      labels: labelsArray
    )
    res = @copyleaks.text_moderation_client.submit_text(_authToken, scanId, text_moderation_request)

    textModerationResponse = Copyleaks::CopyleaksTextModerationResponseModel.new(  
      moderations: res['moderations'],
      legend: res['legend'],
      scanned_document: res['scannedDocument'])

end

    require 'copyleaks'
    require 'base64'
    # --- Your Credentials ---
    USER_EMAIL = 'YOUR_EMAIL_ADDRESS'
    USER_API_KEY = 'YOUR_API_KEY'
    # --------------------
  begin
      puts "Submitting a new image for AI image detection..."
      
      scanId = DateTime.now.strftime('%Q').to_s
      
      # Read and encode your image file to base64 (read it in binary mode)
      image_path = "Path/to/your/image.jpg" # Update this path to your image
      base64_image = Base64.strict_encode64(File.binread(image_path))
      
      model = Copyleaks::CopyleaksAiImageDetectionRequestModel.new(
        base64_image,
        "image.jpg",
        Copyleaks::CopyleaksAiImageDetectionModels::AI_IMAGE_1_ULTRA, 
        true # sandbox mode
      )
      
      res = copyleaks.ai_image_detection_client.submit_(authToken, scanId, model)
    rescue StandardError => e
      puts "Error in test_image_detection: #{e.message}"
    end
  end

model = Copyleaks::CopyleaksAiImageDetectionRequestModel.new(
  nil, 'image.jpg', Copyleaks::CopyleaksAiImageDetectionModels::AI_IMAGE_1_ULTRA, true,
  image: File.binread('Path/to/your/image.jpg'),
  mask_type: Copyleaks::CopyleaksAiImageMaskTypes::HEATMAP, # BINARY (default), HEATMAP or NONE
  object_detection: ['face', 'hand']                        # up to 3 objects
)
res = copyleaks.ai_image_detection_client.check(authToken, scanId, model) # same as submit_
result = Copyleaks::CopyleaksAiImageDetectionResponseModel.from_json(res)
puts "AI detected: #{result.is_ai_detected}, objects: #{Array(result.detected_objects).map(&:object)}"

model = Copyleaks::CopyleaksAiImageDetectionAsyncRequestModel.new(
  url: 'https://example.com/image.png',
  file_name: 'image.png',
  model: Copyleaks::CopyleaksAiImageDetectionModels::AI_IMAGE_1_ULTRA,
  webhooks: Copyleaks::CopyleaksAsyncWebhooksModel.new('https://your-server.com/webhook/ai-image'),
  mask_type: Copyleaks::CopyleaksAiImageMaskTypes::HEATMAP,
  sandbox: true
)
copyleaks.ai_image_detection_client.submit_async(authToken, scanId, model)

# In your webhook handler:
result = Copyleaks::CopyleaksAiImageDetectionResponseModel.from_json(JSON.parse(request_body))
puts "Scan failed: #{result.error.code} #{result.error.message}" if result.error

model = Copyleaks::CopyleaksAiVideoDetectionRequestModel.new(
  url: 'https://example.com/video.mp4',
  filename: 'video.mp4',
  model: Copyleaks::CopyleaksAiVideoDetectionModels::AI_VIDEO_1_PRO,
  webhooks: Copyleaks::CopyleaksAsyncWebhooksModel.new('https://your-server.com/webhook/ai-video'),
  sandbox: true
)
copyleaks.ai_video_detection_client.submit(authToken, scanId, model)

# In your webhook handler:
result = Copyleaks::CopyleaksAiVideoDetectionResponseModel.from_json(JSON.parse(request_body))
if result.error
  puts "Scan failed: #{result.error.code} #{result.error.message}"
else
  puts "AI detected: #{result.is_ai_detected}, overall ratio: #{result.summary.overall_ai_ratio}"
end

model = Copyleaks::CopyleaksImagePlagiarismRequestModel.new(
  image: File.binread('Path/to/your/photo.jpg'),
  filename: 'photo.jpg',
  sandbox: true
)
res = copyleaks.image_plagiarism_client.check(authToken, scanId, model)
result = Copyleaks::CopyleaksImagePlagiarismResponseModel.from_json(res)
puts "Matches: #{result.matches.score.total_matches}"
result.matches.internet.each { |match| puts "#{match.url} (#{match.match_type == 0 ? 'full' : 'partial'})" }

copyleaks.get_credits_balance(authToken)                      # plagiarism credits
copyleaks.ai_detection_client.get_credits_balance(authToken)  # AI Text Detection credits
copyleaks.get_repository_info(authToken, 'my-repo-id')        # Private Cloud Hub repository (Admin role)

# Usage history as CSV. With a block, the CSV is streamed in chunks.
File.open('usage.csv', 'w') do |file|
  copyleaks.get_usages_history_csv(authToken, '01-09-2026', '30-09-2026') { |chunk| file.write(chunk) }
end

# Public lookups, no login needed
copyleaks.get_supported_file_types
copyleaks.get_supported_ai_text_detection_file_types
copyleaks.get_allowed_cross_languages
copyleaks.get_ocr_supported_languages