Use Cases

Industry Use Cases

Tectra is designed to be the universal provenance standard for all digital content. Here is how five key industries integrate it today.

AI Companies Security Cameras & Surveillance Digital Artists & Creators News Organizations & Photojournalism Medical Imaging

AI Companies

Sign every generated image with your model's identity

As AI-generated images flood the internet, the question "Was this made by AI?" has become critical for trust. Tectra lets AI companies cryptographically sign every output image with their organization key, making it trivially verifiable who generated the content and when.

Key Benefits

Prove model provenance - verify exactly which model version generated an image
Comply with emerging AI content labeling regulations (EU AI Act, US EO 14110)
Build user and platform trust by making AI outputs transparently verifiable
Prevent misuse - signed outputs can be traced back to your systems

Integration Flow

Your image generation pipeline → sign via API or SDK → image delivered with embedded provenance → users and platforms verify instantly

Code Example

python

from tectravision_sdk import TectraClient

client = TectraClient(
    api_key="iai_...",
    signing_key_id="model-v3-key-uuid",
    fernet_key="...",
)

# Sign every image your model generates
def generate_and_sign(prompt: str) -> dict:
    image_bytes = my_model.generate(prompt)
    
    result = client.sign(
        image_bytes,
        origin_type="ai_generated_image",
        metadata={"model": "my-model-v3", "prompt_hash": hash(prompt)},
    )
    return {
        "image": result["output_path"],
        "record_id": result["record_id"],
        "certificate": result["certificate"],
    }

Note: The SDK signs locally - your image bytes never leave your infrastructure. Only the hash is sent to Tectra.

Security Cameras & Surveillance

Tamper-evident footage from the moment of capture

Security camera footage is often challenged in court or investigations due to questions about tampering. Tectra's Docker agent drops into any camera output pipeline and signs every frame at capture, creating legally defensible, tamper-evident video evidence.

Key Benefits

Tamper-evident - any modification to footage is instantly detectable
Legal chain of custody - blockchain-anchored timestamps prove when footage was captured
Zero-code integration - Docker agent watches your output directory automatically
Per-camera identity - each device gets its own signing key for granular attribution

Integration Flow

Camera captures frame → saved to output dir → Tectra agent detects new file → signs and watermarks → blockchain anchored

Code Example

yaml

# config.yaml on edge server
tectra:
  api_url: https://tectra.vision
  api_key: iai_...
  signing_key_id: cam-lobby-key-uuid

watch:
  directories:
    - /footage
  patterns: ["*.jpg", "*.jpeg", "*.mp4"]
  recursive: true

output:
  signed_directory: /footage/signed
  keep_originals: true

Note: Each camera can have its own signing key. The device_id appears in verification results, identifying the exact camera.

Digital Artists & Creators

Prove original authorship that survives the internet

Artists lose attribution the moment their work is shared online. Screenshots strip metadata, social media re-encodes everything, and AI training datasets scrape images without credit. Tectra's invisible watermark survives all of this - embedded into the pixels themselves.

Key Benefits

Invisible watermark survives screenshots, re-uploads, and social media compression
Cryptographic proof of creation date - blockchain-anchored timestamp
Perceptual hash catches modified copies - even heavily cropped or color-shifted versions
Share a verification link alongside any published work

Integration Flow

Create artwork → sign before publishing → share online → anyone can verify authorship by uploading to tectra.vision/verify

Code Example

python

from tectravision_sdk import TectraClient

client = TectraClient(api_key="iai_...", signing_key_id="...", fernet_key="...")

# Sign your artwork before publishing
result = client.sign(
    "my_artwork.png",
    origin_type="digital_artwork",
)

print(f"Signed at: {result['certificate']['timestamp']}")
print(f"Verify at: https://tectra.vision/verify")
print(f"Record ID: {result['record_id']}")

# Batch-sign an entire portfolio
import os
for filename in os.listdir("./portfolio"):
    if filename.endswith((".png", ".jpg")):
        client.sign(f"./portfolio/{filename}")
        print(f"Signed: {filename}")

Note: Even if your image is cropped, color-adjusted, or re-compressed by Instagram or Twitter, the perceptual hash check will still match it to your original.

News Organizations & Photojournalism

Unbreakable chain of custody from camera to publication

Trust in photojournalism has been eroded by deepfakes and image manipulation. Tectra provides an unbreakable chain of custody - from the photojournalist's camera, through the editorial desk, to publication - with every step cryptographically verified.

Key Benefits

Prove an image was not altered between capture and publication
Reader-facing verification - embed a QR code or link so readers can verify any photo
Multi-party signing - photographer signs at capture, editor co-signs for publication
Integration with wire services and content management systems

Integration Flow

Photographer captures → auto-sign via camera agent → editor reviews → re-sign at editorial desk → publish with verification metadata

Code Example

yaml

# Photographer signs at capture (Docker agent on laptop)
# config.yaml for field agent
api_key: "iai_..."
signing_key_id: "photographer-jane-key"
origin_type: "photojournalism"
device_id: "Jane-Canon-R5"
watch_dir: "/CF-Card/DCIM"
output_dir: "/CF-Card/signed"

---

# Editorial desk re-signs for publication approval
result = client.sign(
    "assignment_0421.jpg",
    origin_type="editorial_approved",
    metadata={
        "assignment_id": "0421",
        "desk": "foreign",
        "approved_by": "editor-id",
    }
)

Note: Multiple signing keys in a chain create an auditable trail showing who handled the image and when.

Medical Imaging

Tamper-evident audit trail for diagnostic scans

Medical images must not be altered between acquisition and diagnosis. Regulatory requirements (HIPAA, FDA 21 CFR Part 11) demand tamper-evident audit trails. Tectra provides cryptographic proof that a scan was not modified from the moment it left the imaging device.

Key Benefits

Tamper detection - any pixel modification breaks the hash and watermark checks
Regulatory compliance audit trail with blockchain-anchored timestamps
Per-device identity - each MRI, CT, or X-ray machine gets its own signing key
DICOM-compatible pipeline - works alongside existing PACS systems

Integration Flow

Imaging device captures scan → sign immediately at acquisition → store with provenance record → radiologist verifies before diagnosis

Code Example

python

from tectravision_sdk import TectraClient

client = TectraClient(
    api_key="iai_...",
    signing_key_id="mri-unit-7-key",
    fernet_key="...",
)

# Sign immediately after acquisition
def on_scan_complete(dicom_path: str, patient_id: str, study_id: str):
    result = client.sign(
        dicom_path,
        origin_type="medical_imaging",
        device_id="MRI-UNIT-7-WING-B",
        metadata={
            # patient_id hashed - never send PII to Tectra
            "study_id": study_id,
            "modality": "MRI",
            "acquisition_station": "MRI-UNIT-7",
        }
    )
    return result["record_id"]  # Store alongside DICOM

Note: Never include patient PII in metadata. Use anonymized study IDs only. The actual image bytes never leave your infrastructure.

Next: API Reference

Full endpoint documentation with request and response schemas.

API Reference