The Clarifai Public API collection gives you direct access to the full Clarifai REST API — various endpoints across different resource areas. Use it to manage applications, upload inputs, train models, build workflows, search your data, run inference, and orchestrate compute infrastructure — all from Postman.
\nAll requests authenticate using your PAT in the Authorization header:
Authorization: Key <YOUR_PAT>\n\nThe collection uses collection-level auth — your PAT is applied automatically to every request once set. Generate a PAT from your Clarifai account security settings.
\n📖 Authentication Documentation
\nOpen the collection → Variables tab and replace the placeholder values with your own:
\nAll other variables (concept_id, input_id, dataset_id, etc.) follow the same pattern and are used by their respective endpoint groups.
Click the collection name in the sidebar
\nGo to the Variables tab
\nSet key to your PAT, user_id to your username, and app_id to your target app
All 235 requests will automatically use these values
\nAlternatively, create a Postman Environment with the same variable names to switch between accounts or apps without editing the collection directly.
\nBase URL: https://api.clarifai.com
Protocol: HTTPS only
\nAuth header: Authorization: Key YOUR_PAT
Content-Type: application/json (all POST / PATCH / PUT requests)
SDKs: Python | Node.js | gRPC Clients
\nPagination: page and per_page query parameters on all list endpoints — Pagination Docs
Rate Limits: Rate Limits Documentation
\nStatus Codes: Status Codes Reference
\nCreate a new application under the authenticated user's account. An application is the top-level container for all Clarifai resources (inputs, models, workflows, datasets, etc.).
\nRetrieve a paginated list of all applications owned by the authenticated user.
\nSearch for applications across the platform by name or ID.
\nRetrieve detailed information about a specific application.
\nUpdate one or more fields on an existing application, including name, notes, visibility, and metadata. Use the overwrite action to replace all values.
Update specific fields (notes, description, cover image) of an application using its partial update endpoint. Useful for updating metadata without replacing the entire app configuration.
\nChange the base workflow of an application. The base workflow is automatically run on every new input added to the app. Use reindex: true to re-process all existing inputs with the new workflow.
Rename an application by changing its ID. All existing resources within the app remain unchanged.
\nPermanently delete an application and all of its contents (inputs, models, workflows, datasets, annotations). This action is irreversible.
\nList all organizations the authenticated user belongs to.
\nApplications are the top-level containers for all resources on the Clarifai platform — inputs, models, workflows, datasets, annotations, and more. Each application has its own base workflow that runs automatically on every new input added to it.
\nKey operations: create, list, get, patch (update name/notes/visibility/base workflow/ID), delete, list organizations.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID
Retrieve a paginated list of all find-duplicate-annotations jobs for the app. Each job scans annotations using a PCA projection comparator to surface near-duplicate label pairs.
\nRetrieve the status and results of a single find-duplicate-annotations job by its ID.
\nStart a new job to detect duplicate annotations across the app's inputs. The job uses PCA-based embedding comparison; results are available once the job completes.
\nDelete one or more find-duplicate-annotations jobs by ID.
\nFind Duplicate Annotations Jobs identify inputs that have been annotated more than once, helping maintain dataset quality and consistency. This is an enterprise-tier feature.
\nKey operations: post job, get job, list jobs, delete jobs.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_FIND_DUPLICATE_JOB_ID
Create a new annotation filter for the app. Annotation filters define reusable query criteria (concept, region, status, etc.) that can be applied when creating dataset versions or filtering annotations.
\nRetrieve all annotation filters defined in the app.
\nRetrieve a specific annotation filter by ID.
\nDelete one or more annotation filters by ID.
\nAnnotation Filters are reusable filter configurations that define subsets of annotations based on criteria such as concept, task, status, or user. Saved filters can be referenced when creating dataset versions or running search queries.
\nKey operations: post, list, get, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_ANNOTATION_FILTER_ID
Retrieve a specific annotation by its input ID and annotation ID.
\nList all annotations in the app. Use list_all_annotations=true to include system-generated (model) annotations in addition to human annotations.
Add human annotations (labels, bounding boxes, polygons, etc.) to inputs. Annotations created here are attributed to the authenticated user and can be used for model training and evaluation.
\nUpdate existing annotations. Supports merging or overwriting annotation data such as concepts and region labels.
\nDelete one or more annotations by input ID and annotation ID.
\nBulk-update the status of all annotations associated with a labeling task. Useful for approving, rejecting, or resetting annotations as part of a review workflow.
\nList all workers (users and models) that have created annotations in the app.
\nAnnotations are labels attached to inputs (or regions within inputs) used to train and evaluate models. This folder covers the full annotations lifecycle, including creating, filtering, searching, and managing annotation jobs.
\nSubfolders:
\nKey operations: post, patch, delete, list, get, filter by task/status/concept/user, list workers.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_INPUT_ID, YOUR_ANNOTATION_ID, YOUR_ANNOTATION_FILTER_ID
📖 Annotations Documentation | Labeling via API
\n","_postman_id":"4286b9e8-36f1-4666-8444-e327738c9857","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new collector that automatically captures model prediction outputs as new inputs to the app. Collectors enable passive data collection by intercepting API calls to a specified model.
\nUpdate a collector's configuration or status. Use status.code: 52002 to disable a collector, or 52001 to enable it.
Retrieve the full configuration and status of a specific collector.
\nList all collectors configured in the app.
\nDelete one or more collectors by ID.
\nCollectors automatically route inputs from an external model deployment into a Clarifai application. When a model is called via the Collector's trigger key, the inputs and outputs are captured and stored for further review, annotation, or training.
\nKey operations: add, patch, get, list, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_COLLECTOR_ID, YOUR_WORKFLOW_ID
Retrieve a specific concept by its ID.
\nList all concepts defined in the app.
\nGet the total count of concepts in the app, broken down by status.
\nAdd one or more new concepts to the app. Concepts represent labels or categories that can be used to annotate inputs and train models.
\nSearch for concepts in the app by name using a wildcard pattern.
\nSearch for concepts by name in Chinese (or any non-English language). Uses the same search endpoint as English but with a language field set to the target language code.
Update one or more existing concepts. Use overwrite to replace the concept name.
Return the total number of concepts in the app along with a status breakdown.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Retrieve all external references (links, citations, knowledge graph entries) associated with a concept.
\nCore operations for managing concepts within an application — adding, listing, searching, patching, and checking concept counts and references.
\nKey operations: add, get by ID, list, search, patch, get count, get references.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_CONCEPT_ID
📖 Create Concepts | Manage Concepts
\n","_postman_id":"2320b60c-21cd-40d7-b9b8-1aa9a522e68c","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Retrieve a specific concept vocabulary (vocab) by its ID. A vocab is a named, ordered collection of concepts.
\nList all concept vocabularies in the app.
\nCreate a new concept vocabulary (named collection of concepts) in the app.
\nUpdate one or more concept vocabularies, such as renaming them.
\nDelete a single concept vocabulary by ID.
\nDelete multiple concept vocabularies in a single request.
\nList all concepts that belong to a specific vocabulary.
\nAdd one or more concepts to an existing vocabulary.
\nRemove a single concept from a vocabulary.
\nRemove a batch of concepts from a vocabulary in a single request.
\nRemove all concepts from a vocabulary, leaving it empty. The vocabulary itself is not deleted.
\nConcept Vocabularies group related concepts into named sets, making it easier to manage large taxonomies and reuse label sets across models.
\nKey operations: add vocab, get, list, patch, delete vocab, add/list/delete concepts within a vocab.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_VOCAB_ID, YOUR_CONCEPT_ID
List all language translations available for a concept.
\nRetrieve the translated name of a concept in a specific language.
\nUpdate the translated name of a concept in one or more languages.
\nAdd translated names for a concept in one or more languages.
\nConcept Languages enable multilingual support by attaching translated names to concepts. Each concept can have translations in any number of languages identified by a language code (e.g. ko for Korean).
Key operations: list translations, get by language, add translations, patch translations.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_CONCEPT_ID
Retrieve all semantic relations (hypernyms and hyponyms) for a specific concept.
\nRetrieve all semantic relations across all concepts in the app. Returns all hypernym/hyponym pairs defined in the concept graph.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Retrieve all hypernyms (broader/more general concepts) of a given concept. For example, the hypernym of \"labrador\" is \"dog\".
\nRetrieve all hyponyms (narrower/more specific concepts) of a given concept. For example, a hyponym of \"dog\" is \"labrador\".
\nCreate a semantic relation (hyponym or hypernym) between two concepts in the app's concept graph.
\nDelete one or more semantic relations from the concept graph.
\nThe Concept Graph defines hierarchical relationships between concepts using predicates such as hypernym (broader) and hyponym (narrower). This enables structured taxonomies and richer search and filtering.
Key operations: get all relations, filter by predicate (hypernym/hyponym), create relation, delete relation.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_CONCEPT_ID
Concepts are the labels used to annotate inputs and train models. They can be organized into vocabularies, translated into multiple languages, and connected to each other in a hierarchical concept graph.
\nSubfolders:
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_CONCEPT_ID
Create one or more datasets in the app. Datasets are named collections of inputs used for training, evaluation, and version management.
\nRetrieve a paginated list of all datasets in the application.
\nRetrieve details of a specific dataset by ID.
\nUpdate one or more dataset properties such as description and metadata.
\nUpdate a dataset and set a default annotation filter on it. The annotation filter is automatically applied when creating new dataset versions, restricting which annotations are included.
\nDelete one or more datasets by ID. All dataset inputs and versions are also deleted.
\nCore operations for creating and managing datasets within an application, including creating with default annotation filters, patching metadata, and deleting.
\nKey operations: post, list, get, patch, patch with annotation filter, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_DATASET_ID
📖 Create Datasets | Manage Datasets
\n","_postman_id":"a3e36f30-cc49-41f3-bcb3-d3f0ed47265d","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Add existing inputs to a dataset by referencing their input IDs. The inputs must already exist in the app.
\nAdd inputs to a dataset using a search query. All inputs matching the search criteria are added to the dataset.
\nAdd a large number of inputs to a dataset in a single bulk operation. Useful for populating datasets from large input pools.
\nRetrieve a paginated list of all inputs that belong to a specific dataset.
\nRetrieve details of a specific input within a dataset.
\nRemove one or more inputs from a dataset. The inputs themselves are not deleted from the app.
\nManage which inputs belong to a dataset. Inputs can be added by explicit ID, by search query, or via bulk operations. Removing an input from a dataset does not delete the input from the application.
\nKey operations: add by input IDs, add by search, add via bulk operation, list, get, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_DATASET_ID, YOUR_INPUT_ID
Create a new version (snapshot) of a dataset. A dataset version locks the current set of inputs and annotations, enabling reproducible training and evaluation runs.
\nCreate a new dataset version with a specific annotation filter applied. Only annotations matching the filter are included in this version.
\nList all versions of a dataset.
\nRetrieve details and status of a specific dataset version.
\nTrigger an export of a dataset version in a specified format. Exports are generated asynchronously; poll the status using GET.
\nUpdate properties of an existing dataset version, such as description.
\nDelete one or more dataset versions. The underlying inputs are not deleted.
\nDataset Versions capture a fixed snapshot of a dataset's inputs and annotations at a specific point in time. Versions are used to train models reproducibly and can be exported to external storage.
\nKey operations: post version, post with annotation filter, list, get, patch, put exports (trigger export), delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_DATASET_ID, YOUR_DATASET_VERSION_ID
📖 Create Datasets | Manage Datasets
\n","_postman_id":"66d612bb-352d-4a90-be52-d63701ecc140","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Datasets are named collections of inputs and annotations used for model training and evaluation. Dataset Versions capture a snapshot of a dataset at a point in time and can be exported for use outside Clarifai.
\nSubfolders:
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_DATASET_ID, YOUR_DATASET_VERSION_ID
List all inputs in the app. Inputs can be images, videos, audio files, or text.
\nGet a summary of input processing status — how many inputs are queued, processing, complete, or failed.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Stream inputs using cursor-based pagination. More efficient than offset pagination for large datasets. Each response includes a last_id that can be used as the cursor for the next page.
Retrieve a single input by its ID, including its metadata, annotations, and processing status.
\nDelete a single input from the app by its ID.
\nDelete multiple inputs in a single request. Useful for bulk cleanup of large datasets.
\nAdd one or more inputs (images, video, audio, or text) to the app. Inputs are the core data unit in Clarifai and can have concepts, metadata, and geo-coordinates attached at upload time.
\nAdd inputs to the app and receive a job ID to track the progress of the batch. Use the job ID with the input jobs endpoint to poll status.
\nUpdate existing inputs — merge or overwrite concepts, metadata, and geo-coordinates.
\nAdd inputs in bulk from a CSV file hosted at a public URL. The CSV should contain columns for input URLs, concepts, and optional metadata.
\nRetrieve a specific set of inputs by providing a list of input IDs.
\nRetrieve the status of a specific input-adding job to monitor how many inputs have been processed, succeeded, or failed.
\nList all input-adding jobs in the app. Each job tracks the progress of a batch of inputs added via the Add Input with Job endpoint.
\nInputs are the data items (images, video, text, audio) stored in an application. Every input runs through the app's base workflow on ingestion. Inputs can be added individually, in batches, or via CSV, and are the foundation for annotations, search, and model training.
\nKey operations: add, add with job tracking, add via CSV, list, stream, get by ID, get by IDs, patch, delete by ID, delete batch, list/get adding jobs.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_INPUT_ID, YOUR_INPUTS_ADD_JOB_ID
📖 Inputs Documentation | Upload Inputs | Manage Inputs
\n","_postman_id":"7145839a-feca-4593-ac7a-aeeaa0db72aa","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new model with a custom configuration. The model type is specified via model_type_id, which determines the training pipeline and output format.
Create a new version of a model using a custom training configuration. Specify the training template, hyperparameters, and output concepts.
\nCreate a model with a fully custom output configuration. Use this approach when building models that require specific output types, layer configurations, or non-standard architectures not covered by the walkthrough subfolders.
\nKey operations: create model, create model version.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID
📖 Manage Models | Training Templates
\n","_postman_id":"ce4c993f-c23f-4591-a2c3-7177cda8b401","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new visual-classifier model for transfer learning. This model will be fine-tuned on your labeled images using a pre-trained backbone.
\nInitiate transfer learning by creating a new model version. The training uses a ResNet backbone and runs on your annotated dataset.
\nStep-by-step requests for creating a transfer-learned visual classifier. Transfer learning fine-tunes a pre-trained base model (e.g. ResNet) on your labeled images, requiring far less data and compute than training from scratch.
\nSteps: create model → create model version (triggers training with a specified template).
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID
📖 Transfer Learning | Training Templates
\n","_postman_id":"8a72f39d-f0c9-41cd-9809-d9a527f94420","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new visual-classifier model. This is the first step in training a custom image classification model using your own labeled data.
\nUpload labeled images for training a visual classifier. Each input must have concept annotations that correspond to the classes the model will learn.
\nStart training a visual classifier model version with the EfficientNet backbone. Training runs asynchronously; poll the version status to track progress.
\nRun inference on an image using a trained visual classifier version. Returns a ranked list of concepts with confidence scores.
\nEnd-to-end walkthrough for building a visual image classifier: add tagged training images, create the model, create a model version to trigger training, then run predictions once training is complete.
\nSteps: create model → add tagged images → create model version → predict on image.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID, YOUR_VERSION_ID
📖 Transfer Learning — Visual Classifier | Evaluations
\n","_postman_id":"8f2cee61-d2a3-4600-9420-f6340fef2f96","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Add text inputs to the app for use as training data for a text-to-text LLM. Each input can include the raw text and optional concept labels.
\nCreate a new text-to-text LLM model. This model type wraps a HuggingFace language model and supports fine-tuning on your text dataset.
\nFine-tune a text-to-text LLM by creating a new model version. Specify the base HuggingFace model and training configuration.
\nRun inference on a text input using a text-to-text LLM version. Returns the model's generated text response.
\nStep-by-step requests for creating a text-to-text large language model. Add text inputs, define the model, create a model version to initialize it, then run predictions with a text prompt.
\nSteps: add text → create model → create model version → predict on text.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID, YOUR_VERSION_ID
📖 Deep Fine-Tuning | Training Templates
\n","_postman_id":"da9852cb-4015-41a3-9c77-20aa0f22a4fb","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new keyword-filter model. This model scans text inputs for a predefined list of blocked keywords or patterns and returns a confidence score.
\nCreate a version of a keyword-filter model with a specific list of blocked keywords. No training is required — the version is active immediately.
\nCreate a keyword filter model that scans text inputs for specified keywords and returns matches. Useful for content moderation, routing, or tagging pipelines.
\nSteps: create model → create model version.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID
Create a new image-crop model. This model type crops images based on detected regions (e.g., from an object detector), applying a configurable margin.
\nCreate a version of an image-crop model with a specific cropping margin.
\nCreate an image crop model that extracts a sub-region of an image based on detected bounding box coordinates. Typically used downstream of a detection model in a workflow.
\nSteps: create model → create model version.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID
Rename a model by updating its ID. All existing model versions remain associated with the new ID.
\nUpdate one or more model attributes — name, description, metadata, output configuration, or timeout settings.
\nRun inference on one or more inputs using a model. Returns predictions from the model's latest version. Use the /versions/{version_id}/outputs path to predict with a specific version.
Retrieve metadata and status of a specific model version, including training status, output configuration, and inference settings.
\nList all models in the app. Returns both custom models and models copied from the Community.
\nList all versions of a specific model, ordered by creation date.
\nList all available model types (visual-classifier, text-to-text, visual-detector, etc.) and their supported training templates and output configurations.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Retrieve a model's metadata and configuration by its ID.
\nRetrieve the output configuration of a model, including its concept list, output type, and inference parameters.
\nList model versions that were trained on a specific set of concepts. Useful for discovering which model versions can predict a given concept.
\nList the inputs that were used to train a specific model. Requires the model to have been trained at least once. Returns the training dataset inputs.
\nRetrieve or trigger evaluation metrics for a specific model version. Use GET to fetch existing metrics, POST to run a new evaluation.
\nList all available training templates for all model types. Each template defines a set of hyperparameters and architecture defaults for training.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Permanently delete a model and all its versions.
\nDelete a specific model version. The model itself and other versions remain intact.
\nUpdate properties of one or more model versions, such as description and inference compute settings.
\nRetrieve or trigger evaluation metrics for a specific model version. Use GET to fetch existing metrics, POST to run a new evaluation.
\nRun a new evaluation of a model version against a ground-truth dataset. Evaluation computes metrics such as precision, recall, F1, and confusion matrices.
\nRetrieve the results of a specific model evaluation by evaluation ID.
\nList all evaluations that have been run in the app.
\nTrigger an export of a trained model version. The model is packaged for deployment or offline use. Export runs asynchronously — use GET to poll for completion.
\nRetrieve the export status and download URL for a previously triggered model export.
\nSubfolders:
\nKey operations: create model, create version, list, get, patch, predict, evaluate, export, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_MODEL_ID, YOUR_VERSION_ID
📖 Models Documentation | Model Versions | Manage Models | Evaluations | Model Export
\n","_postman_id":"db59e4ea-c0d7-4405-8d59-7862aa1efa61","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new application using the General-1.5 base workflow. This is the first step in the basic search walkthrough — the app uses General-1.5 embeddings for visual similarity search.
\nAdd images to the app. Once processed, these inputs can be searched by visual similarity or concept.
\nList all inputs in the app for verification before running searches.
\nAdd bounding box annotations to images. These annotations define labeled regions within images and can be used as anchors for visual similarity search.
\nList all annotations in the app, including both human annotations and model-generated outputs. Use list_all_annotations=true to include model outputs.
A step-by-step demo that creates an application, adds annotated images with bounding boxes, and runs a basic annotation search. Use this as an introduction to Clarifai's search capabilities before exploring ranked and filtered search.
\nSteps: create app → add inputs → add bounding box annotations → list annotations → search.
\n\n","_postman_id":"36bd5238-eb5c-41f6-b7d7-d18cd6a48284","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Return annotations ranked by visual similarity to a reference input. The input's embedding is used as the query vector.
\nReturn annotations ranked by visual similarity to a reference image URL, with a minimum similarity threshold. Only results above the threshold are returned.
\nRank inputs by their relevance to multiple public concepts combined with OR logic. Results matching any of the specified concepts are ranked by combined relevance score.
\nRank annotations using a combination of visual similarity to an image URL, a concept tag, and a reference input ID. Results are scored across all three signals simultaneously.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Rank annotations using a combination of embedding similarity, a concept tag filter, and a reference input. Combines dense embedding vectors with concept-based filters.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Rank inputs using a raw embedding vector as the search query. Useful for nearest-neighbour search when you already have an embedding.
\nRank annotation search results by visual or semantic similarity. Results can be ranked against a reference image URL, an input ID already in the app, an embedding vector, or a combination of visual and concept signals.
\nKey operations: rank by input ID, rank by image with threshold, rank by public concept (OR), rank by image + tag + input, rank by embedding + tag + input, rank by embedding.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID
Find inputs that have no positive concept annotations. Useful for locating unannotated or negatively-labeled inputs in the dataset.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Find inputs that have no negative concept annotations.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Find inputs that do not have a specific concept annotated as positive. Useful for identifying unlabeled images for a particular class.
\nFind inputs that have no human annotations at all. These are inputs that have been uploaded but not yet labeled — useful for discovering unlabeled data for annotation tasks.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Filter inputs based on their annotation label status. Use these endpoints to find inputs that are unlabeled, have positive labels omitted, or have negative labels omitted — useful for identifying gaps in your training data.
\nKey operations: omit all positive labels, omit all negative labels, omit single positive label, find not-labeled inputs.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID
Filter annotations by a specific custom concept. Returns all annotations in the app where the given concept is present.
\nFilter annotations by concept within a time range. Only annotations created or modified within the specified time window are returned.
\nFilter annotations based on the processing status of their parent inputs.
\nFind annotations that are not labeled with a specific concept. Uses the negate flag to invert the concept filter.
Filter annotations by their review status and the user who created them. Useful for quality-control workflows where you need to review annotations by a specific annotator.
\nFilter annotations associated with a specific labeling task.
\nFilter annotations by both a specific labeling task and the annotator who created them.
\nFilter annotations by concept ID, and optionally rank results by visual similarity. Combines concept-based filtering with image embedding ranking for precision search.
\nAdd images to a General app to make them available for annotation search. This is a preparatory step in annotation search walkthroughs.
\nFilter annotations by a custom concept, then rank the filtered results by visual similarity to a reference image.
\nFilter annotations by a specific input ID and task ID. Returns only annotations on the given input that belong to the specified task.
\nCount inputs that have annotations with bounding box regions. Supports filtering by region size and position.
\nCount inputs that have annotations matching both a specific concept and a bounding box region. Useful for counting region-level labels.
\nFilter inputs that belong to any of the specified datasets. Inputs matching any of the provided dataset IDs are returned.
\nFilter inputs by data modality. Returns only inputs of the specified type (image, video, audio, or text).
\nCount inputs that have at least one annotation with a specific concept. Returns the total count without returning individual inputs.
\nFilter annotations using structured query criteria. Filters can be combined with rank operations for hybrid search. Supports filtering by concept, task, user, input status, annotation status, bounding box region, dataset, and input type.
\nKey operations: filter by concept, by concept with time range, by input status, by concept negation, by annotation status + user, by task, by task + user, by dataset (OR), by input type, by bounding box region, count filters, filter + rank by image.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID
📖 Filter Search | Combine or Negate
\n","_postman_id":"a60ab69d-8a21-47a0-9f72-52fcf34d1f46","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Compute search quality metrics by comparing a search query against a ground-truth annotation set. Returns precision, recall, and mAP scores.
\nList all previously computed annotation search metric results in the app.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Retrieve a specific annotation search metric result by its ID.
\nDelete a specific annotation search metric result by its ID.
\nAnnotation Search Metrics measure the quality of search results — computing precision, recall, and related statistics for a given search query against a ground-truth annotation set. This is an advanced feature that may require a specific plan.
\nKey operations: post metrics job, list metrics, get by ID, delete by ID.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_ANNOTATION_SEARCH_METRICS_ID
The Search folder provides endpoints for finding inputs and annotations using ranked similarity search and structured filters. Searches can be combined — rank by visual similarity while filtering by concept, status, task, bounding box, or dataset.
\nSubfolders:
\nVariables required: YOUR_USER_ID, YOUR_APP_ID
📖 Search Documentation | Filter | Rank | Combine or Negate
\n","_postman_id":"da1378f2-3db4-416e-b6cd-5c826be08ce1","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"List all workflows in the app.
\nRetrieve a specific workflow and its node configuration by workflow ID.
\nCreate a new workflow by chaining one or more model nodes. Each node references a model by ID and version, and can receive inputs from other nodes via node_inputs.
Update an existing workflow — modify node configuration, add/remove nodes, or rename the workflow.
\nRun a workflow on a video input by URL. The video is decoded into frames and each frame is passed through the workflow nodes. Returns per-frame predictions.
\nDelete multiple workflows by ID in an asynchronous operation.
\nDelete all custom workflows in the app asynchronously. The default base workflow is not deleted.
\n","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Delete a specific workflow by ID.
\nCompare two inputs using a workflow's embedding output. Returns a similarity score by computing the cosine distance between the embedding vectors produced by the workflow for each input.
\nCore operations for managing workflows: creating multi-node pipelines, running predictions on images or video, patching workflow nodes, and deleting workflows individually or in batch.
\nKey operations: list, get, create, patch, predict (image/video), predict similarity (embedding comparison), delete by ID, delete batch, delete all.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_WORKFLOW_ID
📖 Create Workflows | Workflow Inferences
\n","_postman_id":"a0f0f7a3-c800-42a8-8c5e-dc753c7793db","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"List all workflow metric sets in the app. Workflow metrics evaluate a workflow's predictions against ground truth annotations.
\nRetrieve computed metrics for a specific workflow metric set.
\nRetrieve metrics broken down per node within a workflow. Useful for identifying which node in a multi-model pipeline is underperforming.
\nRun a workflow evaluation against all concepts defined in the app. Computes precision, recall, and F1 per concept.
\nRun a workflow evaluation scoped to a single concept. Returns precision and recall for that concept only.
\nRun a workflow evaluation using a custom search query to define ground truth. Enables flexible evaluation against any subset of annotations.
\nDelete a specific workflow metrics set.
\nWorkflow Metrics evaluate how well a workflow performs against a labeled dataset by computing per-concept precision and recall. Metrics can be computed for all concepts in the app or scoped to a single concept, and can use a custom ground-truth search.
\nKey operations: add metrics (all concepts), add metrics (one concept), add with ground truth search, list, get, get node metrics, delete.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_WORKFLOW_ID, YOUR_WORKFLOW_METRICS_ID
List all versions of a specific workflow. Each time a workflow is modified, a new version is created automatically.
\nRetrieve the configuration of a specific workflow version.
\nUpdate properties of a specific workflow version, such as its description.
\nDelete a specific workflow version. The workflow itself and other versions remain intact.
\nWorkflow Versions are immutable snapshots of a workflow's node configuration at a point in time. Use versions to roll back to a previous workflow structure or compare performance across iterations.
\nKey operations: list versions, get version, patch version, delete version.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_WORKFLOW_ID, YOUR_WORKFLOW_VERSION_ID
Workflows chain multiple models together into a single prediction pipeline. Each node in a workflow feeds its output to the next, enabling complex multi-step inference (e.g. detect → crop → classify). Workflows can be versioned and evaluated against labeled data.
\nSubfolders:
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_WORKFLOW_ID, YOUR_WORKFLOW_VERSION_ID
📖 Workflows Documentation | Create Workflows | Workflow Inferences | Base Workflows
\n","_postman_id":"0b441390-c2af-4ceb-85d1-a8503abdf25b","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"List all pipelines in the app. Pipelines are multi-step data processing graphs that chain models, transformations, and custom logic.
\nRetrieve the full configuration and status of a specific pipeline.
\nDelete one or more pipelines by ID. Associated pipeline versions and runs are also deleted.
\nCore operations for retrieving and managing pipelines within an application.
\nKey operations: list pipelines, get pipeline by ID, delete pipelines.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_PIPELINE_ID
List all versions of a specific pipeline.
\nRetrieve the configuration of a specific pipeline version.
\nPipeline Versions are versioned snapshots of a pipeline's step configuration. Each version defines the exact sequence of operations that will run when the pipeline is executed.
\nKey operations: list versions, get version by ID.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_PIPELINE_ID, YOUR_PIPELINE_VERSION_ID
Start a new execution run of a pipeline version. The pipeline processes its input data asynchronously — use GET to poll the run status.
\nGet the current status and progress of a specific pipeline run.
\nUpdate the state of a pipeline run — for example, to pause, cancel, or resume execution.
\nRetrieve log entries for a pipeline run. Logs include per-step status, error messages, and timing information.
\nPipeline Runs represent a single execution of a pipeline version. Runs can be started, monitored for status, and inspected via log entries. A run can also be patched to update its state.
\nKey operations: post run (execute), get run, patch run, list log entries.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_PIPELINE_ID, YOUR_PIPELINE_VERSION_ID, YOUR_PIPELINE_VERSION_RUN_ID
List all pipeline step versions available in the app. Pipeline steps are the individual processing units that make up a pipeline.
\nRetrieve the configuration of a specific pipeline step version.
\nPipeline Steps are the individual operation units within a pipeline version. Each step has its own versioned definition that specifies the transformation or action it performs.
\nKey operations: list step versions, get step version.
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_PIPELINE_STEP_ID, YOUR_PIPELINE_STEP_VERSION_ID
Pipelines are multi-step data processing orchestrations that run sequences of operations on inputs — such as ingestion, transformation, annotation, and export — in a defined order. Each pipeline is versioned and can be executed as a run.
\nSubfolders:
\nVariables required: YOUR_USER_ID, YOUR_APP_ID, YOUR_PIPELINE_ID, YOUR_PIPELINE_VERSION_ID, YOUR_PIPELINE_VERSION_RUN_ID
📖 Pipelines Documentation | Create and Run Pipelines | Manage Pipeline Runs
\n","_postman_id":"98fcfe1f-fee6-447f-932d-baa0af6c3347","auth":{"type":"apikey","apikey":{"basicConfig":[{"key":"key","value":"Authorization"},{"key":"value","value":"Create a new artifact in the app. Artifacts are versioned file objects (model weights, configs, datasets, etc.) that can be uploaded, versioned, and referenced by pipelines and models.
\n