Built for the workflows
where authenticity matters.

from aiimagedetector import Client
client = Client(api_key=os.environ["AIDET_KEY"])

def verify_for_publication(image_url, story_id):
    result = client.detect(
        image_url=image_url,
        include_attribution=True,
        include_heatmap=True,
        metadata={"story_id": story_id, "context": "editorial"}
    )
    if result.confidence > 0.85 and result.verdict == "ai_generated":
        flag_for_desk_review(story_id, result)
    elif result.c2pa_manifest_present:
        attach_provenance_chain(story_id, result.c2pa_manifest)
    log_verification(story_id, result.request_id, result.verdict)

// Node.js , claim-intake middleware
import { Client } from "@aiimagedetector/node";
const ai = new Client({ apiKey: process.env.AIDET_KEY! });

export async function scanClaimPhoto(req, res, next) {
  const result = await ai.detect({
    imageUrl: req.body.photoUrl,
    includeAttribution: true,
    includeHeatmap: true,
    includeForensics: true,
    metadata: { claimId: req.body.claimId, policyholder: req.user.id }
  });

  if (result.confidence > 0.8 && result.verdict !== "authentic") {
    await routeTo SIU(req.body.claimId, result);
    return res.status(202).json({ status: "under_review" });
  }
  next();
}

# Python , KYC verification step
def verify_kyc(user_id, liveness_video_url, id_photo_url):
    video_check = client.detect(
        image_url=liveness_video_url,
        include_attribution=True,
        metadata={"user_id": user_id, "step": "kyc_liveness"}
    )
    id_check = client.detect(
        image_url=id_photo_url,
        include_attribution=True,
        metadata={"user_id": user_id, "step": "kyc_id"}
    )
    if video_check.verdict == "ai_generated" or id_check.verdict == "ai_generated":
        return KYCResult.STEP_UP_REQUIRED
    if video_check.confidence < 0.6:
        return KYCResult.MANUAL_REVIEW
    return KYCResult.APPROVED

# Batch scanning at ingest
const batch = await ai.detectBatch({
  images: listing.photos.map(p => ({ url: p.url, ref: p.id })),
  includeAttribution: true,
  metadata: { listingId: listing.id, sellerId: listing.sellerId }
});

const flagged = batch.results.filter(r =>
  r.verdict === "ai_generated" && r.confidence > 0.7
);

if (flagged.length > 0) {
  await rejectListing(listing.id, flagged);
} else if (batch.results.some(r => r.confidence < 0.6)) {
  await queueForReview(listing.id, batch);
} else {
  await publishListing(listing.id);
}

# Webhook receiver
@app.post("/webhooks/detection")
def receive_verdict(req):
    if not verify_signature(req.body, req.headers["X-Signature"], SECRET):
        return 403
    
    event = req.json()
    if event["type"] != "detection.completed":
        return 200
    
    policy_decision = policy_engine.decide(
        detection=event["data"],
        user_history=user_signals(event["data"]["metadata"]["user_id"]),
        content_type=event["data"]["metadata"]["surface"]
    )
    apply_action(event["data"]["metadata"]["upload_id"], policy_decision)
    log_for_dsa(event, policy_decision)
    return 200

// Profile photo upload handler
app.post('/api/profile/photo', async (req, res) => {
  const upload = await uploadToCDN(req.file);
  const verdict = await ai.detect({
    imageUrl: upload.url,
    includeAttribution: true,
    metadata: { userId: req.user.id, photoSlot: req.body.slot }
  });

  if (verdict.confidence > 0.75 && verdict.verdict === 'ai_generated') {
    await deleteFromCDN(upload.url);
    return res.status(400).json({
      error: 'AI-generated photos are not permitted in profiles. Please upload a real photo of yourself.',
      learn_more: '/help/photo-policy'
    });
  }

  await saveProfilePhoto(req.user.id, upload.url, verdict);
  if (verdict.confidence < 0.3) await awardVerificationBadge(req.user.id);
  return res.json({ url: upload.url, verified: verdict.confidence < 0.3 });
});

# Pre-publication asset check
async def review_submission(asset):
    if asset.contributor_label == "ai_generated":
        return PublishWithLabel("ai_generated")
    
    verdict = await ai.detect_async(
        image_url=asset.url,
        webhook_url="https://api.example.com/webhooks/asset",
        metadata={"asset_id": asset.id, "contributor": asset.contributor_id}
    )
    return PendingDetection(verdict.job_id)

# In webhook handler
def handle_verdict(event):
    asset_id = event["metadata"]["asset_id"]
    if event["confidence"] > 0.85 and event["verdict"] == "ai_generated":
        flag_label_mismatch(asset_id, event)
        notify_contributor(asset_id, "Please confirm AI-generated label")
    else:
        publish_asset(asset_id)

// LMS integration , scan assignment submission
async function scanSubmission(submissionId, files) {
  const images = files.filter(f => f.type.startsWith('image/'));
  if (images.length === 0) return { ok: true };
  
  const batch = await ai.detectBatch({
    images: images.map(i => ({ url: i.url, ref: i.id })),
    metadata: { submissionId, courseId: files[0].courseId }
  });
  
  const flagged = batch.results.filter(r => 
    r.confidence > 0.8 && r.verdict === 'ai_generated'
  );
  
  if (flagged.length > 0) {
    await flagForFacultyReview(submissionId, flagged);
  }
  
  return { ok: true, scanned: batch.results.length, flagged: flagged.length };
}

# Generate court-defensible forensic report
def forensic_report(case_id, image_path):
    result = client.forensics(
        image_path=image_path,
        include_all_signals=True,
        metadata={
            "case_id": case_id,
            "investigator": current_user.id,
            "chain_of_custody_id": coc_id
        }
    )
    
    report = ForensicReport(
        case_id=case_id,
        request_id=result.request_id,
        ai_verdict=result.verdict,
        confidence=result.confidence,
        model_attribution=result.model_attribution,
        ela_signature=result.forensics.ela,
        frequency_signature=result.forensics.frequency,
        noise_residual=result.forensics.noise,
        c2pa_chain=result.c2pa,
        heatmap_url=result.heatmap_url,
        methodology=result.methodology_doc
    )
    return report.export_pdf(signed=True)

# High-value wire transfer approval middleware
def authorize_wire(transfer_request, video_session):
    if transfer_request.amount < HIGH_VALUE_THRESHOLD:
        return standard_approval(transfer_request)
    
    # Sample frames from the authorization video call
    frames = sample_frames(video_session, count=10)
    detection = client.detect_batch(
        images=[{"url": f.url, "ref": f.timestamp} for f in frames],
        metadata={
            "transfer_id": transfer_request.id,
            "amount": transfer_request.amount,
            "approver_user_id": transfer_request.approver_id
        }
    )
    
    deepfake_frames = [r for r in detection.results 
                       if r.confidence > 0.7 and "deepfake" in r.tags]
    
    if deepfake_frames:
        return require_callback_verification(transfer_request, detection)
    return approve_wire(transfer_request)