Best AI Video Tagging Tools in 2026

import boto3

rekognition = boto3.client("rekognition")
response = rekognition.start_label_detection(
    Video={"S3Object": {"Bucket": "my-bucket", "Name": "video.mp4"}},
    MinConfidence=80,
    NotificationChannel={
        "SNSTopicArn": "arn:aws:sns:us-east-1:123456789:video-labels",
        "RoleArn": "arn:aws:iam::123456789:role/RekognitionRole"
    }
)
job_id = response["JobId"]
# Poll for results
result = rekognition.get_label_detection(JobId=job_id, SortBy="TIMESTAMP")
for label in result["Labels"][:10]:
    print(f"{label['Timestamp']}ms: {label['Label']['Name']} ({label['Label']['Confidence']:.1f}%)")

import requests

account_id = "YOUR_ACCOUNT_ID"
api_key = "YOUR_API_KEY"
location = "trial"

# Upload and index a video
url = f"https://api.videoindexer.ai/{location}/Accounts/{account_id}/Videos"
params = {"name": "my-video", "videoUrl": "https://example.com/video.mp4", "accessToken": api_key}
response = requests.post(url, params=params)
video_id = response.json()["id"]

# Get tags after processing
index_url = f"{url}/{video_id}/Index"
result = requests.get(index_url, params={"accessToken": api_key})
for label in result.json()["summarizedInsights"]["labels"]:
    print(f"{label['name']}: {len(label['appearances'])} appearances")

from google import genai
import time

client = genai.Client()

myfile = client.files.upload(file="clip.mp4")
while not myfile.state or myfile.state.name != "ACTIVE":
    time.sleep(5)
    myfile = client.files.get(name=myfile.name)

interaction = client.interactions.create(
    model="gemini-3.5-flash-lite",
    input=[
        {"type": "video", "uri": myfile.uri, "mime_type": myfile.mime_type},
        {"type": "text", "text": "Tag this clip using only these tags: product_demo, testimonial, "
                                 "outdoor, indoor, logo_visible. Return JSON with each tag and the "
                                 "seconds where it applies."},
    ],
)
print(interaction.output_text)

from twelvelabs import TwelveLabs
from twelvelabs.types import VideoContext_AssetId, AnalyzePromptV2
import time

client = TwelveLabs(api_key="YOUR_API_KEY")
asset = client.assets.create(method="url", url="https://example.com/video.mp4")
while client.assets.retrieve(asset.id).status != "ready":
    time.sleep(5)

text_stream = client.analyze_stream(
    model_name="pegasus1.6",
    video=VideoContext_AssetId(asset_id=asset.id),
    prompt_v_2=AnalyzePromptV2(
        input_text="Tag each segment as product_demo, testimonial or b_roll, with start and end seconds.",
    ),
)
for text in text_stream:
    if text.event_type == "text_generation":
        print(text.text)

from roboflow import Roboflow
import supervision as sv

rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("my-workspace").project("my-project")
model = project.version(1).model

# Process video frames
import cv2
cap = cv2.VideoCapture("video.mp4")
while cap.isOpened():
    ret, frame = cap.read()
    if not ret: break
    predictions = model.predict(frame, confidence=40).json()
    for pred in predictions["predictions"]:
        print(f"{pred['class']}: {pred['confidence']:.2f} at ({pred['x']}, {pred['y']})")
cap.release()

import requests

url = "https://api.thehive.ai/api/v2/task/sync"
headers = {"Authorization": "Token YOUR_API_KEY"}
data = {
    "url": "https://example.com/video.mp4",
    "models": {
        "visual_moderation": {},
        "violence_detection": {}
    }
}
response = requests.post(url, headers=headers, json=data)
for frame in response.json()["status"]:
    for model, result in frame["response"].items():
        top_class = max(result["output"], key=lambda x: x["score"])
        print(f"Frame: {top_class['class']} ({top_class['score']:.3f})")

import requests

# Deploy model and run inference via Datature API
url = "https://api.datature.io/v1/predict"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"file": open("frame.jpg", "rb")}
data = {"model_id": "model_abc123", "confidence_threshold": 0.5}

response = requests.post(url, headers=headers, files=files, data=data)
predictions = response.json()["predictions"]
for pred in predictions:
    print(f"{pred['label']}: {pred['confidence']:.2f} "
          f"bbox=({pred['x1']}, {pred['y1']}, {pred['x2']}, {pred['y2']})")

from google.cloud import videointelligence_v1 as videointelligence

client = videointelligence.VideoIntelligenceServiceClient()
features = [videointelligence.Feature.LABEL_DETECTION]
operation = client.annotate_video(
    request={"input_uri": "gs://my-bucket/video.mp4", "features": features}
)
result = operation.result(timeout=300)
for label in result.annotation_results[0].segment_label_annotations:
    print(f"{label.entity.description}: {label.segments[0].confidence:.2f}")

from clarifai_grpc.grpc.api import resources_pb2, service_pb2
from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
from clarifai_grpc.grpc.api.status import status_code_pb2

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2.V2Stub(channel)
metadata = (("authorization", "Key YOUR_API_KEY"),)

response = stub.PostModelOutputs(
    service_pb2.PostModelOutputsRequest(
        model_id="general-image-recognition",
        inputs=[resources_pb2.Input(data=resources_pb2.Data(
            video=resources_pb2.Video(url="https://example.com/video.mp4")
        ))]
    ), metadata=metadata
)
for frame in response.outputs[0].data.frames:
    concepts = [f"{c.name}:{c.value:.2f}" for c in frame.data.concepts[:3]]
    print(f"Frame {frame.frame_info.time}ms: {', '.join(concepts)}")