What Is Amazon Rekognition? Pricing per Image, Free Tier, Features, Python Tutorial, Custom Labels and Face Liveness

Amazon Rekognition is AWS's ready-made computer vision service: you send it an image or a video and it tells you what is in it, with no machine learning model to train or host. It finds objects, scenes and activities (labels), detects and compares faces, searches a collection of millions of faces, flags unsafe or explicit content, reads short text in photos, recognizes celebrities, checks safety equipment, and confirms that a selfie is a live person (Face Liveness). Image analysis costs $0.001 per image ($1 per 1,000) for the first million a month, falling to $0.0004 or less at very high volume; stored video costs $0.10 per minute; Face Liveness costs $0.015 per check; and Custom Labels, which trains Rekognition on your own objects, costs $1 per training hour and $4 per hour while a model is running. Accounts on the classic AWS Free Tier get 1,000 images of each API group and 60 minutes of video free every month for 12 months. Below: what Rekognition is and how it works, every feature, every price with worked examples, a Python tutorial, Custom Labels, content moderation, face search and liveness, video, the 2026 change for streaming and bulk analysis, Rekognition vs Textract, Bedrock models, YOLO and Azure, limits and error fixes.

The furniture store had a photo problem. Its website showed 4,000 products, each with five or six photos taken over eight years by whoever had a phone that day, half of them with no description and some, the owner suspected, showing the wrong sofa. On top of that, customers had started uploading photos with their reviews, and the owner wanted to be sure nothing unpleasant ever appeared on the product pages. Jake suggested hiring a student for the summer to look at every picture. Ethan asked how fast the student could look at 24,000 photos, and uploaded the first one to the Rekognition console.

Building with Rekognition? The cards below cover Lambda, S3 access, Bedrock Data Automation, free local OCR and billing alerts, the pieces you will most often need around it.

What is Amazon Rekognition?

Computer vision is the part of artificial intelligence that lets software understand pictures: what objects are in a photo, whether two photos show the same person, whether an image is safe to publish. Building that yourself means collecting millions of labeled images, training deep learning models on GPUs and running them on servers. Amazon Rekognition is AWS's pre-trained version: an API, plus a console for trying it, that has already learned to recognize thousands of everyday things and answers in a fraction of a second.

You call it like any other AWS service. Send an image (as bytes or a reference to an object in an S3 bucket) to an operation such as DetectLabels, and you get back JSON: each thing it found, a confidence score from 0 to 100, and for many objects a bounding box showing where in the image it is. Video works the same way, through jobs that analyze files in S3 and report results with timestamps.

Is Rekognition SaaS? In practice, yes: it is a fully managed AI service you use over an API, with no servers, models or GPUs to manage, billed per image or minute. It is also Regional: you choose the AWS Region, your data is processed there, and resources such as face collections and custom models live in that Region only.

Does Rekognition use AI? Entirely. Every feature is a deep learning model trained by AWS, and Custom Labels lets you fine-tune one on your own images without writing machine learning code.

Jake: "So it looks at a picture and tells you what's in it."

Ethan: "In about a second, for a tenth of a cent. It just called this photo 'Couch, Furniture, Living Room, Cushion, Lamp', and it drew a box around the lamp."

How Amazon Rekognition works

1. You put images or videos in S3 (or send small images directly as bytes, up to 5 MB).
2. Your code calls an API operation for the job you need: labels, faces, moderation, text, celebrities, protective equipment, or a custom model.
3. Rekognition runs the matching deep learning model on its own servers in your chosen Region.
4. It returns JSON with labels, confidence scores, bounding boxes, face details or timestamps; for video, it notifies an SNS topic when the job finishes and you fetch the results.
5. Your code decides what to do: tag the product, hide the review photo, unlock the door, or send the image to a person for review when confidence is low.

Confidence scores are the key to using Rekognition well. Every answer comes with a number from 0 to 100, and you choose the threshold: MinConfidence of 90 returns only answers it is very sure of; 60 returns more, with more mistakes. A moderation system might auto-approve below 50, auto-reject above 90, and send everything in between to a person.

Amazon Rekognition features

Feature	API operation	What it returns	Typical use
Labels (objects, scenes, activities)	DetectLabels	Thousands of possible labels with categories, confidence and boxes	Photo tagging, search, catalog cleanup
Image properties	DetectLabels (IMAGE_PROPERTIES)	Dominant colors, brightness, sharpness, contrast	Rejecting blurry photos, color search
Content moderation	DetectModerationLabels	Explicit, suggestive, violent, drug, hate-symbol and other unsafe categories	User uploads, ads, marketplaces
Face detection and analysis	DetectFaces	Face boxes, landmarks, age range, smile, glasses, eyes open, expressions	Photo cropping, quality checks
Face comparison	CompareFaces	Similarity score between a source face and faces in a target image	Identity checks against an ID photo
Face search	IndexFaces, SearchFacesByImage, SearchUsersByImage	Matches from a collection of up to 20 million faces	Face sign-in, photo organization
Face Liveness	CreateFaceLivenessSession + UI component	Score that the user is a live person, not a photo, video or mask	Onboarding, account recovery, KYC
Text in images	DetectText	Up to 100 words, lines and their positions	Signs, license plates, product labels
Celebrity recognition	RecognizeCelebrities	Names and reference links for well-known people	Media archives, news
Protective equipment	DetectProtectiveEquipment	Face, hand and head covers on up to 15 people	Workplace safety checks
Custom Labels	DetectCustomLabels	Your own labels, trained on your images	Damage detection, your products, logos
Video analysis	StartLabelDetection, StartFaceSearch, StartContentModeration, StartSegmentDetection and more	The same answers with timestamps, plus shots and technical cues	Video libraries, ad breaks, moderation

About facial expressions: DetectFaces with all attributes returns expressions such as happy, sad, angry, confused, surprised, calm and fear, each with a confidence. They describe how a face appears in that photo, not what the person actually feels, so treat them as a rough signal (for picking the smiling photo in a set), never as a judgment about a person.

Amazon Rekognition pricing

US East (N. Virginia) prices in October 2026. Image APIs are billed per image analyzed, in two groups with monthly volume tiers:

Images per month	Group 1 (face indexing, search, compare)	Group 2 (labels, faces, moderation, text, celebrities, PPE)	Image Properties
First 1 million	$0.001 ($1.00 per 1,000)	$0.001 ($1.00 per 1,000)	$0.00075
Next 4 million	$0.0008	$0.0008	$0.0006
Next 30 million	$0.0006	$0.0006	$0.00045
Over 35 million	$0.0004	$0.00025	$0.0001875

• Group 1 covers IndexFaces, SearchFacesByImage, SearchFaces, CompareFaces, AssociateFaces, DisassociateFaces, SearchUsers and SearchUsersByImage.
• Group 2 covers DetectLabels, DetectFaces, DetectModerationLabels, DetectText, RecognizeCelebrities and DetectProtectiveEquipment.
• Each call is one image, so running labels and moderation on the same photo is two images, and asking for image properties with labels adds the Image Properties charge.
• Face storage: $0.01 per 1,000 face vectors (and per 1,000 user vectors) stored per month.
• Custom Moderation: $5 per training hour; inference from $0.0012 per image for the first million, down to $0.0003 above 30 million.
• Face Liveness: $0.015 per check for the first 500,000 a month, $0.0125 for the next 2.5 million, $0.010 beyond 3 million.
• Custom Labels: $1 per training hour and $4 per hour per inference unit while the model is running, whether or not you send it images.
• Stored video: $0.10 per minute for label detection, content moderation, face detection, face search, celebrity recognition and text; $0.05 per minute each for shot detection and technical cue detection.
• Streaming video (for existing users of that feature): $0.00817 per minute for label detection on connected-home events (up to 120 seconds per event), $0.12 per minute for streaming face search, plus Kinesis Video Streams charges.

On top of Rekognition itself you pay for S3 storage of your images, SNS notifications for video jobs, and Lambda if your pipeline runs there. Use the AWS Pricing Calculator for a full estimate, or the quick formula: images per month x $0.001 per API you call covers most small and mid-sized projects.

Is Amazon Rekognition free? The free tier

Not permanently, but it starts free. Accounts on the classic AWS Free Tier get, every month for the first 12 months:

• 1,000 images analyzed with Group 1 APIs and 1,000 images with Group 2 APIs (Image Properties is not included);
• 1,000 face vectors and 1,000 user vectors stored;
• 60 minutes of stored video analysis (labels, moderation, faces, face search, celebrities, text and person pathing);
• Custom Labels: 2 training hours and 1 inference hour;
• Custom Moderation: 2 training hours.

Accounts created from July 15, 2025 use the newer credit-based Free Tier instead: up to $200 of credits that Rekognition can draw on. Either way, the console demos (upload an image on the Label detection, Face comparison or Content moderation pages) are billed like API calls, so trying a few dozen photos costs nothing or a few cents.

Worked examples: what Rekognition really costs

Example 1: the store's catalog cleanup. 24,000 product photos run once through DetectLabels with image properties (to flag blurry and dark photos): 24,000 x ($0.001 + $0.00075) = $42, one time. The labels went into the website's search, and 600 photos flagged as blurry or with no furniture label went to Ethan for a second look; 40 turned out to show the wrong product.

Example 2: moderating review photos. About 3,000 customer photos a month through DetectModerationLabels: $3 a month, or $2 once the free 1,000 are used. Photos with any moderation label above 60 percent confidence wait for a person to approve them.

Ethan: "Forty-two dollars for the whole catalog, and three dollars a month to keep the reviews clean."

Jake: "The student would have cost more than that in pizza."

Example 3: a photo-sharing app at scale. 2.5 million images a month, labels only: 1,000,000 x $0.001 + 1,500,000 x $0.0008 = $2,200 a month. Adding moderation on every image doubles it to $4,400.

Example 4: face sign-in for staff tablets. 40 staff indexed once (40 Group 1 images, $0.04), then 40 x 4 sign-ins a day x 30 days = 4,800 searches a month: $4.80 a month, plus a fraction of a cent for face storage. Adding a Face Liveness check to every sign-in adds 4,800 x $0.015 = $72; most teams use liveness only at enrollment and for unusual sign-ins.

Example 5: identity checks at onboarding. 400,000 new users a month, each with a liveness check and a CompareFaces against their ID photo: liveness $6,000 + comparisons 400,000 x $0.001 ($400) = $6,400 a month.

Example 6: analyzing warehouse video. Two cameras, 8 hours a day, sent as stored video for label detection: 2 x 480 minutes x 30 days = 28,800 minutes x $0.10 = $2,880 a month. Sampling one frame every 5 seconds instead and sending the frames to DetectLabels gives 345,600 images: $345.60 a month, which is plenty for "is someone in the loading bay after hours".

Example 7: a Custom Labels model left running. A model that detects torn or stained upholstery on returned sofas, on one inference unit: training about 1 hour ($1), then $4 an hour while running. Left on all month: 720 x $4 = $2,880. Started for one hour each afternoon to check the day's return photos: 30 x $4 = $120 a month. A billing alert on day one catches the first version before it hurts.

Amazon Rekognition tutorial: analyze images with Python

1. Put a test image in S3 in a Region where Rekognition runs, for example s3://store-photos/sofas/aalborg-3-seat.jpg. JPEG and PNG are supported, up to 15 MB from S3.
2. Give your user or role permission: the AWS managed AmazonRekognitionReadOnlyAccess policy covers the detect and search operations for experiments; production apps should allow only the operations they call, plus s3:GetObject on the image bucket.
3. Install boto3 (pip install boto3) and configure credentials with aws configure or IAM Identity Center.
4. Run the label example below, then try moderation, text and faces on the same image.
5. Automate it with a Lambda function triggered by new uploads, once the results look right.

import boto3

rek = boto3.client("rekognition", region_name="us-east-1")
image = {"S3Object": {"Bucket": "store-photos", "Name": "sofas/aalborg-3-seat.jpg"}}

# Labels: objects, scenes and activities
labels = rek.detect_labels(Image=image, MaxLabels=15, MinConfidence=80)
for label in labels["Labels"]:
    boxes = len(label.get("Instances", []))
    print(f'{label["Name"]:20} {label["Confidence"]:5.1f}%  boxes: {boxes}')

# Moderation: unsafe content, with its category
mod = rek.detect_moderation_labels(Image=image, MinConfidence=60)
print("Moderation:", [(m["Name"], round(m["Confidence"])) for m in mod["ModerationLabels"]] or "none")

# Text in the photo (price tags, signs), up to 100 words
text = rek.detect_text(Image=image)
print("Text:", [t["DetectedText"] for t in text["TextDetections"] if t["Type"] == "LINE"])

To send a local file instead of an S3 object, pass the bytes: Image={"Bytes": open("photo.jpg", "rb").read()}, up to 5 MB. From the command line, the same label call is:

aws rekognition detect-labels --region us-east-1 --max-labels 10 \
  --image '{"S3Object":{"Bucket":"store-photos","Name":"sofas/aalborg-3-seat.jpg"}}'

An automatic pipeline: an S3 event notification on the uploads prefix triggers a Lambda function that calls Rekognition and writes the labels as S3 object tags or into a database, and moves anything flagged by moderation to a quarantine prefix. For bursts of uploads, put an SQS queue between S3 and Lambda so calls are spread out under your Rekognition requests-per-second quota; see our guide to Lambda throttling for the concurrency side.

Rekognition from other languages: every AWS SDK (JavaScript, Java, .NET, Go, PHP, Ruby) has the same operations with the same names, and in a browser or mobile app you can call it with temporary credentials from a Cognito identity pool, or upload to S3 with a presigned URL and analyze on the server.

Content moderation with Rekognition

DetectModerationLabels checks an image for unsafe content and returns labels in a three-level hierarchy: a broad top-level category (such as explicit, non-explicit nudity of intimate parts, swimwear or underwear, violence, visually disturbing, drugs and tobacco, alcohol, rude gestures, gambling and hate symbols), then narrower second- and third-level labels, each with a confidence score. You decide which categories matter for your platform: a swimwear store will allow swimwear; a children's education site will not.

• Thresholds: start strict (block above 80, review between 50 and 80) and tune on real images from your own users.
• Human review: route uncertain images to a review queue; Amazon Augmented AI (A2I) provides a ready-made human review workflow, or build a simple admin page.
• Custom Moderation: if the built-in model is wrong too often for your content (for example, it flags artistic paintings you allow), train an adapter with your own labeled images. Training costs $5 an hour and adapted inference $0.0012 per image for the first million.
• Video moderation: StartContentModeration analyzes stored videos and returns moderation labels with timestamps, at $0.10 per minute.
• Text in images: moderation labels cover the picture, not the words in it; run DetectText and a text filter if offensive text in memes or signs matters to you.

Face detection, comparison, search and Face Liveness

Rekognition separates four face jobs, and they are priced and governed differently:

• Detection (DetectFaces, Group 2): finds faces and describes them (box, landmarks, pose, quality, glasses, eyes open, smile, age range, expressions). It does not know who anyone is. A face must be at least 40 x 40 pixels in a 1920 x 1080 image to be detected.
• Comparison (CompareFaces, Group 1): compares the largest face in a source image with faces in a target image and returns a similarity score, the usual way to match a selfie against an ID document.
• Search (Group 1): you create a face collection, add faces with IndexFaces (Rekognition stores a mathematical face vector, not the photo), and later search it with SearchFacesByImage. A collection holds up to 20 million faces. Users group several face vectors of the same person (CreateUser, AssociateFaces), and SearchUsersByImage then matches against the whole set, which is more accurate than single photos.
• Face Liveness: confirms that the person in front of the camera is real and present, not a printed photo, a video replay, a mask or a digitally injected video. Your backend creates a session with CreateFaceLivenessSession; the user completes a short video check in the FaceLivenessDetector component from AWS Amplify (for React web apps, Android and iOS); your backend calls GetFaceLivenessSessionResults and gets a confidence score plus a reference image you can then compare with an ID photo.

Secure face login, a common reason people look at Rekognition, combines them: enroll the user with a liveness check and IndexFaces into their user vector, then at sign-in run liveness and SearchUsersByImage with a high similarity threshold (99 percent is a common starting point). Treat face matching as one factor alongside a password, passkey or device, not as the only lock.

Rules that come with faces: face vectors are biometric data in many laws (Illinois BIPA, Texas and Washington statutes in the US, GDPR in Europe, and others), so get explicit consent, explain how long you keep the data, and delete faces (DeleteFaces, DeleteUser) when people leave or ask. AWS's own terms also require that you use face features lawfully and with appropriate human review for decisions that affect people's rights.

Rekognition Custom Labels: train it on your own objects

The built-in labels know "couch" but not "our Aalborg three-seater in slate gray", and they know "furniture" but not "torn upholstery". Custom Labels trains a model for your own categories without machine learning expertise:

1. Create a project in the Rekognition Custom Labels console.
2. Create a dataset from images in S3, organized in folders by label (the folder names become labels), or upload and label images in the console. A few dozen good images per label is a sensible start; more varied images improve accuracy.
3. Label whole images (classification: "damaged" or "fine") or draw boxes around objects (detection: where the stain is).
4. Train the model. Rekognition picks the algorithm and splits off test images; small projects usually train in under an hour, billed at $1 an hour.
5. Read the evaluation: precision, recall and F1 per label, and the test images it got wrong.
6. Start the model with one or more inference units ($4 per unit per hour), call DetectCustomLabels, then stop the model when you are done.

project = "arn:aws:rekognition:us-east-1:111122223333:project/sofa-returns/1729400000000"
version = "sofa-returns.2026-10-21"
arn = "arn:aws:rekognition:us-east-1:111122223333:project/sofa-returns/version/sofa-returns.2026-10-21/1729500000000"

rek.start_project_version(ProjectVersionArn=arn, MinInferenceUnits=1)
rek.get_waiter("project_version_running").wait(ProjectArn=project, VersionNames=(version,))

result = rek.detect_custom_labels(ProjectVersionArn=arn, MinConfidence=70,
                                  Image={"S3Object": {"Bucket": "store-returns", "Name": "2026-10-21/r1042.jpg"}})
print([(l["Name"], round(l["Confidence"])) for l in result["CustomLabels"]])

rek.stop_project_version(ProjectVersionArn=arn)   # the $4 an hour stops here

Popular Custom Labels uses: damage detection (dents, cracks, scratches, stains on returns, vehicles or packages), finding your own products or logos on shelves and in social media photos, sorting items on a production line, and recognizing plant diseases or machine parts. Because the cost is per running hour, it suits batch work (start, process the day's images, stop) better than an always-on endpoint with light traffic; for that, a model you host yourself may be cheaper.

Rekognition Video: stored video, streaming, and the 2026 change

Stored video analysis works on MP4 and MOV files in S3, encoded with H.264, up to 10 GB and 6 hours each, with up to 20 jobs running at once per account. You start a job (StartLabelDetection, StartFaceDetection, StartFaceSearch, StartCelebrityRecognition, StartContentModeration, StartTextDetection or StartSegmentDetection), Rekognition publishes to an SNS topic when it finishes, and the matching Get operation returns results with timestamps. Segment detection finds shot changes and technical cues (black frames, color bars, end credits), which media teams use to place ad breaks and trim content.

Streaming video connects a Kinesis Video Streams camera feed to a Rekognition stream processor for face search against a collection or for connected-home events (person, pet or package detected). Important 2026 change: since April 30, 2026, streaming video analysis and bulk (batch) image analysis are no longer available to new customers. Accounts that used them within the previous 12 months keep access, and every other Rekognition feature is unaffected. For new projects, the replacement is the same as the frame-sampling idea in Example 6: grab frames from your video (for example with a small Lambda or container reading the stream) and send them to the image APIs, and for big batches of stored images, loop over them with the image APIs from Lambda or a batch job. Our list of AWS services and features retired in 2026 covers the rest of that announcement.

Jake: "So you can't point it at a live camera anymore?"

Ethan: "Not as a new customer. But a camera can drop a photo every few seconds, and the photo service is cheaper anyway."

Amazon Rekognition use cases

• E-commerce and catalogs: auto-tagging product photos, color search, finding blurry or mislabeled images, visual similarity.
• User-generated content: moderating uploads on marketplaces, dating apps, forums, games and review sites.
• Identity verification: selfie-to-ID matching and liveness for banks, fintech, gig platforms and age-restricted services.
• Media and entertainment: searching video archives by person or object, celebrity tagging, ad-break detection, compliance checks.
• Workplace safety: checking for helmets, masks and gloves in site photos.
• Insurance and logistics: damage detection on vehicles, parcels and returns with Custom Labels.
• Smart home and security: person, pet and package alerts from camera snapshots.
• Accessibility: generating alt text from labels as a starting point for image descriptions.

Object detection in practice: "object detection" means not only naming what is in a picture but saying where. DetectLabels returns a bounding box (Instances) for common objects such as people, cars, chairs, dogs and packages, with the box given as fractions of the image width and height, so you can crop, count or draw on the image. Counting people in a queue photo, checking that every pallet in a loading-bay photo has a label, or cropping product photos around the sofa are all a few lines of code on top of those boxes. Objects that have no box in the built-in model, or that only matter to your business, are what Custom Labels detection projects are for.

What Rekognition is a poor fit for: reading full documents (use Textract), judging subjective things like "is this photo attractive", making decisions about people without human review, and anything that needs an answer offline or at the edge without a network connection.

Try Amazon Rekognition in the console (the demo)

The quickest way to see what Rekognition can do with your own images is the console, with no code:

1. Sign in to the AWS console, choose a Region such as US East (N. Virginia), and open Amazon Rekognition.
2. Under Demos, choose Label detection, upload a photo (or use the sample), and read the labels, confidence scores and boxes. Expand Image properties to see colors and quality.
3. Try Image moderation with a few of your platform's real uploads to see which categories it returns.
4. Open Face comparison, add a reference photo and a group photo, and see the similarity scores.
5. Try Text in image on a photo of a sign or a price tag, and Celebrity recognition and PPE detection if they matter to you.
6. Expand Request and Response under any demo to see the exact JSON your code will send and receive.

Each demo image is a billed API call (inside the free tier for most people), so testing 50 of your own images costs, at worst, a few cents, and tells you more about accuracy on your content than any benchmark.

The Rekognition API in one list

• Images: DetectLabels, DetectModerationLabels, DetectFaces, CompareFaces, DetectText, RecognizeCelebrities, DetectProtectiveEquipment.
• Face collections: CreateCollection, IndexFaces, ListFaces, DeleteFaces, SearchFaces, SearchFacesByImage; users: CreateUser, AssociateFaces, SearchUsers, SearchUsersByImage, DeleteUser.
• Liveness: CreateFaceLivenessSession, GetFaceLivenessSessionResults.
• Stored video: Start and Get pairs for labels, faces, face search, celebrities, moderation, text and segments (for example StartLabelDetection and GetLabelDetection).
• Custom Labels: CreateProject, CreateProjectVersion (train), StartProjectVersion, DetectCustomLabels, StopProjectVersion.
• Custom Moderation: adapters are project versions of a moderation project, passed to DetectModerationLabels with ProjectVersion.

Three habits save time with these operations. First, the video Get operations page their results: keep calling them with the NextToken from each response until it is empty, within 24 hours of the job finishing, or you will only see the first batch of labels. Second, filter on the server side where you can: DetectLabels accepts Settings with inclusion and exclusion filters for labels and categories, so you only get back what your application cares about, and MaxLabels and MinConfidence trim the response further. Third, store the full JSON response next to the image the first time you analyze it; if you later change your thresholds, you can re-decide from the saved results instead of paying to analyze the same images again.

Rekognition vs Textract, Bedrock models, YOLO, SageMaker and Azure

• Rekognition vs Textract: Rekognition's DetectText reads short text in photos (signs, labels, plates), up to 100 words. Amazon Textract reads documents: pages, forms, tables, invoices, receipts and IDs, with structure. For documents, use Textract or Bedrock Data Automation; for free local document OCR, see LightOnOCR-3.
• Rekognition vs Comprehend and Transcribe: different senses. Comprehend analyzes text (sentiment, entities), Transcribe turns speech into text, Rekognition analyzes pictures.
• Rekognition vs multimodal models on Bedrock: models such as Amazon Nova can describe an image in sentences, answer questions about it and follow instructions ("is the cushion torn?"), which is more flexible. Rekognition is faster, cheaper per image at volume, returns consistent structured labels and boxes, and has purpose-built face search, liveness and moderation. Many pipelines use Rekognition to filter and tag, and a multimodal model only for the hard cases.
• Rekognition vs YOLO and other open-source detectors: YOLO-family models run on your own GPU or edge device, free per image, with real-time speed and full control, but you host, scale and (for your own objects) train them. Rekognition needs no infrastructure. Choose YOLO for edge devices, offline use or very high volume with steady traffic; Rekognition for fast results with no ML operations.
• Rekognition vs SageMaker: SageMaker is for building and hosting your own models; use it when neither Rekognition nor Custom Labels fits, or when you need a model architecture of your own.
• Rekognition vs Azure AI Vision and Google Cloud Vision: similar per-image pricing and features for labels, OCR and moderation. Pick the cloud where your data already lives. Microsoft limits face identification in Azure AI Face to approved customers, which matters if face search is your core feature.

Free alternatives: open-source models (YOLO for objects, InsightFace-style libraries for faces, open moderation classifiers) cost nothing per image but need your own hardware and care; for a few hundred images a month, Rekognition's free tier is the easier route.

Limits and quotas

• Image size: up to 15 MB from S3, 5 MB as raw bytes (4 MB for protective equipment); JPEG and PNG only; at least 80 x 80 pixels; up to 10,000 pixels on each side for labels and moderation.
• Faces: at least 40 x 40 pixels in a 1920 x 1080 image; up to 20 million face vectors and 10 million user vectors per collection; up to 4,096 matches returned by a search.
• Text: up to 100 words per image.
• Protective equipment: up to 15 people per image, each at least 100 x 100 pixels in an 800 x 1300 image.
• Stored video: H.264 in MP4 or MOV, up to 10 GB and 6 hours, 20 concurrent jobs per account; result tokens expire after 24 hours.
• Requests per second: default quotas per operation and Region, viewable and adjustable in Service Quotas, with usage history per operation.

Common Amazon Rekognition errors and fixes

• InvalidImageFormatException: the file is not a real JPEG or PNG (WebP, HEIC from iPhones, GIF or a renamed file). Convert it first, for example with Pillow in your Lambda function.
• ImageTooLargeException: over 5 MB as bytes or 15 MB from S3, or over the pixel limit. Resize to around 1,920 pixels on the long side, which keeps accuracy for most jobs.
• InvalidS3ObjectException or AccessDenied on S3: wrong bucket or key, the bucket is in a different Region from the Rekognition client, or the caller lacks s3:GetObject (and kms:Decrypt for KMS-encrypted objects).
• ProvisionedThroughputExceededException or ThrottlingException: you exceeded the operation's requests per second, often with a sudden burst. Smooth traffic through a queue, retry with exponential backoff and jitter, and request a quota increase with your peak calculation if you need more.
• ResourceNotFoundException: the collection or model does not exist in this Region, or the Custom Labels model is not started.
• ResourceNotReadyException: a Custom Labels model is still starting; wait for the running state.
• No faces found: faces too small, too dark, turned away or blurred; check Quality in DetectFaces and use larger, frontal images.
• Video job never reports back: the SNS topic name must start with AmazonRekognition when you use the standard service role, or the role passed in NotificationChannel lacks permission to publish.
• Unexpected bill: a Custom Labels model left running, or the same image analyzed several times by a retry loop. Check Cost Explorer by usage type and stop models you are not using.

Best practices

• Pick thresholds on your own data, measured on a few hundred real images, rather than trusting defaults.
• Keep humans in the loop for decisions that affect people: moderation appeals, identity checks, anything legal or financial.
• Analyze once, store the result: save labels with the image so you never pay twice for the same photo.
• Resize before sending: smaller images upload faster and stay within limits, with little accuracy loss.
• Sample video frames when you only need occasional answers; it is far cheaper than per-minute video analysis.
• Stop Custom Labels models when idle, and automate start and stop around batch jobs.
• Handle face data carefully: consent, retention rules and deletion when users leave.
• Stay in one Region for the bucket, the Rekognition client and the collections.

Frequently asked questions

By the end of the week, every product photo on the website had labels, the search box could find "gray corner sofa", and 40 wrong photos had been replaced. Review photos now waited a few seconds for a moderation check before appearing, and the handful that scored high went to the owner's inbox. The total Rekognition bill for the cleanup and the first month of moderation came to $45. Jake asked whether it could also tell which sofas customers liked best. "It can tell you what's in the photo," Ethan said. "Liking is still the customer's job."

Revision note. Written October 21, 2026. Prices are US East (N. Virginia) list prices on that date. We will update this page when Rekognition prices or features change.