Manage Models | Clarifai Docs

GPU Shortage?Make the most out of your GPUs with Compute Orchestration. Learn More

On this page

Learn how to get, update, search, and delete models

info

Before using the Python SDK, CLI, Node.js SDK, or any of our gRPC clients, ensure they are properly installed on your machine. Refer to their respective installation guides for instructions on how to install and initialize them.

Get

List Model Types

Learn about the available model types and their hyperparameters. This endpoint lets you list all the possible models that are creatable (when creatable=true) or generally in the platform (the other ones have creatable=false).

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

################################################################
# In this section, we set the user authentication and app ID.
# Change these strings to run your own example.
################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'

##########################################################################
# YOU DO NOT NEED TO CHANGE ANYTHING BELOW THIS LINE TO RUN THIS EXAMPLE
##########################################################################

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

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

response = stub.ListModelTypes(
    service_pb2.ListModelTypesRequest(
        user_app_id=userDataObject
    ),
    metadata=metadata
    )

if response.status.code != status_code_pb2.SUCCESS:
    print(response.status)
    raise Exception("List models failed, status: " + response.status.description)

for model_type in response.model_types:
  print(model_type)

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and app ID.
    // Change these strings to run your own example.
    ////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';

///////////////////////////////////////////////////////////////////////////////////
    // YOU DO NOT NEED TO CHANGE ANYTHING BELOW THIS LINE TO RUN THIS EXAMPLE
    ///////////////////////////////////////////////////////////////////////////////////

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/types?per_page=20&page=1`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

/////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and app ID.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// YOU DO NOT NEED TO CHANGE ANYTHING BELOW THIS LINE TO RUN THIS EXAMPLE
/////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.ListModelTypes(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        page: 1,
        per_page: 500
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Received status: " + response.status.description + "\n" + response.status.details);
        }

for (const model_type of response.model_types) {
            console.log(model_type)
        }
    }
);

package com.clarifai.example;

import com.clarifai.grpc.api.*;
import com.clarifai.grpc.api.status.StatusCode;
import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;

public class ClarifaiExample {

////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and app ID.
    // Change these strings to run your own example.
    ///////////////////////////////////////////////////////////////////

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiModelTypeResponse listModelTypesResponse = stub.listModelTypes(
            ListModelTypesRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .build()
        );

if (listModelTypesResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("List models failed, status: " + listModelTypesResponse.getStatus());
        }

for (ModelType modelType: listModelTypesResponse.getModelTypesList()) {
            System.out.println(modelType);
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and app ID.
// Change these strings to run your own example.
///////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";

use Clarifai\ClarifaiClient;
use Clarifai\Api\ListModelTypesRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->ListModelTypes(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new ListModelTypesRequest([\
            "user_app_id" => $userDataObject\
        ]),
        $metadata
    )->wait();

// A response is returned and the first thing we do is check the status of it
// A successful response will have a status code of 0; otherwise, there is some error
if ($status->code !== 0) {
    throw new Exception("Error: {$status->details}");
}
// In addition to the RPC response status, there is a Clarifai API status that reports if the operation was a success or failure
// (not just that the communication was successful)
if ($response->getStatus()->getCode() != StatusCode::SUCCESS) {
    throw new Exception("Failure response: " . $response->getStatus()->getDescription() . " " . $response->getStatus()->getDetails());
}

foreach ($response->getModelTypes() as $modelType) {
    echo $modelType->serializeToJsonString() . "\n";
}

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/types?per_page=20&page=1" \
    -H "Authorization: Key YOUR_PAT_HERE"

List Models

Below is an example of how to get a list of all the models you've created in your app.

info

The ListModels endpoint will return details of all the models in your app, alongside the details of their latest versions.

tip

If you want to get a list of the models not within the scope of your app, you need to use your PAT while specifying the user_id of their owner and the app_id of the application that you’re accessing. For example, to get Clarifai's models in the main app, you need to use your PAT while specifying Clarifai's user_id as "clarifai" and app_id as "main" in the request.

Python SDK
CLI
Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

import os
from clarifai.client import User

os.environ["CLARIFAI_PAT"] = "YOUR_PAT_HERE"

user = User()

# Get all models of current user
user.list_models(show=True)

# Or, get models of a specific user_id such as openai
#user.list_models(show=True, user_id="openai")

# Get all models of current user
clarifai model list

# Or, get models of a specific user_id such as openai
#clarifai model list openai

#################################################################
# In this section, we set the user authentication and app ID.
# Change these strings to run your own example.
#################################################################

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

list_models_response = stub.ListModels(
    service_pb2.ListModelsRequest(
         user_app_id=userDataObject
    ),
    metadata=metadata
)

if list_models_response.status.code != status_code_pb2.SUCCESS:
    print(list_models_response.status)
    raise Exception("List models failed, status: " + list_models_response.status.description)

for model in list_models_response.models:
    print(model)

<!--index.html file-->

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.ListModels(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("List models failed, status: " + response.status.description);
        }

for (const model of response.models) {
            console.log(JSON.stringify(model, null, 2));
        }
    }
);

package com.clarifai.example;

import com.clarifai.grpc.api.*;
import com.clarifai.grpc.api.status.StatusCode;
import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;
import java.util.List;

public class ClarifaiExample {

////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and app ID.
    // Change these strings to run your own example.
    /////////////////////////////////////////////////////////////////

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiModelResponse listModelsResponse = stub.listModels(
            ListModelsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .build()
        );

if (listModelsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("List models failed, status: " + listModelsResponse.getStatus());
        }

List<Model> models = listModelsResponse.getModelsList();
        for (Model model : models) {
            System.out.println(model);
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

use Clarifai\ClarifaiClient;
use Clarifai\Api\ListModelsRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->ListModels(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new ListModelsRequest([\
            "user_app_id" => $userDataObject\
        ]),
        $metadata
    )->wait();

foreach ($response->getModels() as $model) {
    echo $model->serializeToJsonString() . "\n";
}

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/" \
    -H "Authorization: Key YOUR_PAT_HERE"

Output Example


user_id    app_id           id                                model_type          url                                                                                 supported_openai_client    UNARY_UNARY    UNARY_STREAMING    STREAMING_STREAMING
---------  ---------------  --------------------------------  ------------------  ----------------------------------------------------------------------------------  -------------------------  -------------  -----------------  ---------------------
openai     tts              openai-tts-1-hd                   text-to-audio       https://clarifai.com/openai/tts/models/openai-tts-1-hd                              False                      ['predict']
openai     chat-completion  gpt-4o                            multimodal-to-text  https://clarifai.com/openai/chat-completion/models/gpt-4o                           True                       ['predict']    ['generate']
openai     chat-completion  gpt-4_1                           multimodal-to-text  https://clarifai.com/openai/chat-completion/models/gpt-4_1                          True                       ['predict']    ['generate']
openai     chat-completion  o3                                multimodal-to-text  https://clarifai.com/openai/chat-completion/models/o3                               True                       ['predict']    ['generate']
openai     chat-completion  o4-mini                           multimodal-to-text  https://clarifai.com/openai/chat-completion/models/o4-mini                          True                       ['predict']    ['generate']
openai     embed            text-embedding-ada-002            text-embedder       https://clarifai.com/openai/embed/models/text-embedding-ada-002                     True                       ['predict']
openai     whisper          whisper-large-v3                  audio-to-text       https://clarifai.com/openai/whisper/models/whisper-large-v3                         False                      ['predict']
openai     transcription    whisper                           audio-to-text       https://clarifai.com/openai/transcription/models/whisper                            False                      ['predict']
openai     completion       gpt-3_5-turbo-instruct            text-to-text        https://clarifai.com/openai/completion/models/gpt-3_5-turbo-instruct                False                      ['predict']
openai     tts              openai-tts-1                      text-to-audio       https://clarifai.com/openai/tts/models/openai-tts-1                                 False                      ['predict']
openai     whisper          whisper-large-v2                  audio-to-text       https://clarifai.com/openai/whisper/models/whisper-large-v2                         False                      ['predict']
openai     embed            text-embedding-ada                text-embedder       https://clarifai.com/openai/embed/models/text-embedding-ada                         False                      ['predict']
openai     embed            text-embedding-3-large            text-embedder       https://clarifai.com/openai/embed/models/text-embedding-3-large                     False                      ['predict']
openai     embed            text-embedding-3-small            text-embedder       https://clarifai.com/openai/embed/models/text-embedding-3-small                     False                      ['predict']
openai     dall-e           DALL-E                            text-to-image       https://clarifai.com/openai/dall-e/models/DALL-E                                    False                      ['predict']
openai     dall-e           dall-e-3                          text-to-image       https://clarifai.com/openai/dall-e/models/dall-e-3                                  False                      ['predict']
openai     chat-completion  GPT-3_5-turbo                     text-to-text        https://clarifai.com/openai/chat-completion/models/GPT-3_5-turbo                    False                      ['predict']
openai     chat-completion  GPT-4                             text-to-text        https://clarifai.com/openai/chat-completion/models/GPT-4                            False                      ['predict']
openai     chat-completion  gpt-4-turbo                       text-to-text        https://clarifai.com/openai/chat-completion/models/gpt-4-turbo                      False                      ['predict']
openai     chat-completion  gpt-4o-mini                       multimodal-to-text  https://clarifai.com/openai/chat-completion/models/gpt-4o-mini                      False                      ['predict']
openai     chat-completion  o1-preview                        text-to-text        https://clarifai.com/openai/chat-completion/models/o1                               False                      ['predict']
openai     chat-completion  o1-mini                           text-to-text        https://clarifai.com/openai/chat-completion/models/o1-mini                          False                      ['predict']
openai     Auto-Labelling   workflow-model-0b0a-342dc669ef03  annotation-writer   https://clarifai.com/openai/Auto-Labelling/models/workflow-model-0b0a-342dc669ef03  False                      ['predict']
openai     Auto-Labelling   workflow-model-1b18-0b926d4b87ea  prompter            https://clarifai.com/openai/Auto-Labelling/models/workflow-model-1b18-0b926d4b87ea  False                      ['predict']

Get Model by ID

All models have unique IDs. You can get a specific model by its ID.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

################################################################################
# In this section, we set the user authentication, app ID, and the model ID we
# want to get its details. Change these strings to run your own example.
################################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change to your own model ID
MODEL_ID = 'petsID'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

get_model_response = stub.GetModel(
    service_pb2.GetModelRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID
    ),
    metadata=metadata
)

if get_model_response.status.code != status_code_pb2.SUCCESS:
    print(get_model_response.status)
    raise Exception("Get model failed, status: " + get_model_response.status.description)

model = get_model_response.model
print(model)

<!--index.html file-->

<script>
    //////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the model ID we
    // want to get its details. Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change to your own model ID
    const MODEL_ID = 'petsID';

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/${MODEL_ID}`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to get its details. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.GetModel(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("List models failed, status: " + response.status.description);
        }

const model = response.model;
        console.log(JSON.stringify(model, null, 2));
    }
);

package com.clarifai.example;

public class ClarifaiExample {

///////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the model ID we
    // want to get its details. Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change to your own model ID
    static final String MODEL_ID = "petsID";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

SingleModelResponse getModelResponse = stub.getModel(
            GetModelRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .build()
        );

if (getModelResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Get model failed, status: " + getModelResponse.getStatus());
        }

Model model = getModelResponse.getModel();
        System.out.println(model);

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

///////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to get its details. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change to your own model ID
$MODEL_ID = "petsID";

use Clarifai\ClarifaiClient;
use Clarifai\Api\GetModelRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->GetModel(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new GetModelRequest([\
            "user_app_id" => $userDataObject,\
            "model_id"=> $MODEL_ID\
        ]),
        $metadata
    )->wait();

$model = $response->getModel();
echo $model->serializeToJsonString();

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE" \
    -H "Authorization: Key YOUR_PAT_HERE"

Get Model Output Info by ID

The output info of a model lists the concepts contained in the latest version of the model—unless a particular version is specified.

note

The GetModelOutputInfo endpoint does not support pagination. If you want to split your results into pages, use the below-described ListModelConcepts endpoint.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

###############################################################################
# In this section, we set the user authentication, app ID, and the model ID we
# want to get its output info. Change these strings to run your own example.
###############################################################################

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

get_model_response = stub.GetModelOutputInfo(
    service_pb2.GetModelRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID
    ),
    metadata=metadata
)

model = get_model_response.model
print(model)

<!--index.html file-->

<script>
    //////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the model ID we
    // want to get its output info. Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/${MODEL_ID}/output_info`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to get its output info. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.GetModelOutputInfo(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("List models failed, status: " + response.status.description);
        }

const model = response.model;
        console.log(JSON.stringify(model, null, 2));
    }
);

package com.clarifai.example;

public class ClarifaiExample {

///////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the model ID we
    // want to get its output info. Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

SingleModelResponse getModelOutputInfoResponse = stub.getModelOutputInfo(
            GetModelRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .build()
        );

if (getModelOutputInfoResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Get model output info failed, status: " + getModelOutputInfoResponse.getStatus());
        }

Model model = getModelOutputInfoResponse.getModel();
        System.out.println(model);
    }

}

<?php

require __DIR__ . "/vendor/autoload.php";

///////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to get its output info. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////////

use Clarifai\ClarifaiClient;
use Clarifai\Api\GetModelRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->GetModelOutputInfo(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new GetModelRequest([\
            "user_app_id" => $userDataObject,\
            "model_id"=> $MODEL_ID\
        ]),
        $metadata
    )->wait();

$model = $response->getModel();
echo $model->serializeToJsonString();

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/output_info" \
    -H "Authorization: Key YOUR_PAT_HERE"

List Model Concepts

Apart from the GetModelOutputInfo endpoint, you can also use the ListModelConcepts endpoint to list the concepts in your model.

A major difference between the two is that the ListModelConcepts endpoint supports pagination, which lets you easily list concepts instead of displaying all of them at once.

info

If you are using any of the Clarifai gRPC clients, the ListModelConcepts endpoint is only available from release 8.10.0.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

###########################################################################
# In this section, we set the user authentication and model ID.
# Change these strings to run your own example.
###########################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change this to whatever model you want to retrieve its concepts
MODEL_ID = 'YOUR_MODEL_ID_HERE'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

list_model_concepts_response = stub.ListModelConcepts(
    service_pb2.ListModelConceptsRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID
    ),
    metadata=metadata
)

if list_model_concepts_response.status.code != status_code_pb2.SUCCESS:
    print(list_model_concepts_response.status)
    raise Exception("List model concept failed, status: " + list_model_concepts_response.status.description)

print(list_model_concepts_response)

<!--index.html file-->

<script>
    ///////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and model ID.
    // Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    //Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change this to whatever model you want to retrieve its concepts
    const MODEL_ID = 'YOUR_MODEL_ID_HERE';

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        },
    };

fetch("https://api.clarifai.com/v2/users/" + USER_ID + "/apps/" + APP_ID + "/models/" + MODEL_ID + "/concepts", requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));
</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and model ID.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////

const USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
const PAT = "YOUR_PAT_HERE";
const APP_ID = "YOUR_APP_ID_HERE";
// Change this to whatever model you want to retrieve its concepts
const MODEL_ID = "YOUR_MODEL_ID_HERE"

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.ListModelConcepts(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("List model versions failed, status: " + response.status.description);
        }

console.log(response);

}

);

package com.clarifai.example;

public class ClarifaiExample {

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change this to whatever model you want to retrieve its concepts
    static final String MODEL_ID = "YOUR_MODEL_ID_HERE";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
                .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiConceptResponse listModelConceptsResponse = stub.listModelConcepts(
                ListModelConceptsRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setModelId(MODEL_ID)
                        .build()
        );

if (listModelConceptsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("List model versions failed, status: " + listModelConceptsResponse.getStatus());
        }

System.out.println(listModelConceptsResponse);

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

//////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and model ID.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change this to whatever model you want to retrieve its concepts
$MODEL_ID = "petsID";

use Clarifai\ClarifaiClient;
use Clarifai\Api\ListModelConceptsRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->ListModelConcepts(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new ListModelConceptsRequest([\
            "user_app_id" => $userDataObject,\
            "model_id"=> $MODEL_ID\
        ]),
        $metadata
    )->wait();

echo($response->serializeToJsonString());

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/concepts" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \

List Model Versions

Every time you train a model, it creates a new version. You can list all the versions created.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

###############################################################################
# In this section, we set the user authentication, app ID, and the model ID we
# want to list its versions. Change these strings to run your own example.
###############################################################################

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

list_model_versions_response = stub.ListModelVersions(
    service_pb2.ListModelVersionsRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID
    ),
    metadata=metadata
)

if list_model_versions_response.status.code != status_code_pb2.SUCCESS:
    print(list_model_versions_response.status)
    raise Exception("List model versions failed, status: " + list_model_versions_response.status.description)

for model_version in list_model_versions_response.model_versions:
    print(model_version)

<!--index.html file-->

<script>
    //////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the model ID we
    // want to list its versions. Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/${MODEL_ID}/versions`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to list its versions. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.ListModelVersions(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("List model versions failed, status: " + response.status.description);
        }

for (const model_version of response.model_versions) {
            console.log(JSON.stringify(model_version, null, 2));
        }
    }
);

package com.clarifai.example;

public class ClarifaiExample {

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiModelVersionResponse listModelVersionsResponse = stub.listModelVersions(
            ListModelVersionsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .build()
        );

if (listModelVersionsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("List model versions failed, status: " + listModelVersionsResponse.getStatus());
        }

List<ModelVersion> modelVersions = listModelVersionsResponse.getModelVersionsList();
        for (ModelVersion modelVersion : modelVersions) {
            System.out.println(modelVersion);
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

//////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the model ID we
// want to list its versions. Change these strings to run your own example.
/////////////////////////////////////////////////////////////////////////////////////

use Clarifai\ClarifaiClient;
use Clarifai\Api\ListModelVersionsRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->ListModelVersions(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new ListModelVersionsRequest([\
            "user_app_id" => $userDataObject,\
            "model_id"=> $MODEL_ID\
        ]),
        $metadata
    )->wait();

foreach ($response->getModelVersions() as $modelVersion) {
    echo $modelVersion->serializeToJsonString() . "\n";
}

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/versions" \
    -H "Authorization: Key YOUR_PAT_HERE"

Get Model Version by ID

To get the details of a specific model version, you must provide the model_id as well as the version_id parameters. You can inspect the model version status to determine if your model is trained or still training.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

#########################################################################################
# In this section, we set the user authentication, app ID, and the ID and version
# of the model we want to get its details. Change these strings to run your own example.
#########################################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change these to your own model ID and version
MODEL_ID = 'petsID'
MODEL_VERSION_ID = 'daf51b311c8644a486bbbe57c0680bc2'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

get_model_version_response = stub.GetModelVersion(
    service_pb2.GetModelVersionRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID,
        version_id=MODEL_VERSION_ID
    ),
    metadata=metadata
)

if get_model_version_response.status.code != status_code_pb2.SUCCESS:
    print(get_model_version_response.status)
    raise Exception("Get model version failed, status: " + get_model_version_response.status.description)

model_version = get_model_version_response.model_version
print(model_version)

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the ID and version
    // of the model we want to get its details. Change these strings to run your own example.
    ///////////////////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change these to your own model ID and version
    const MODEL_ID = 'petsID';
    const MODEL_VERSION_ID = '7625a111b626438bb81a34c3b84d732f';

const requestOptions = {
        method: 'GET',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/${MODEL_ID}/versions/${MODEL_VERSION_ID}`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the ID and version
// of the model we want to get its details. Change these strings to run your own example.
///////////////////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.GetModelVersion(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID,
        version_id: MODEL_VERSION_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Get model version failed, status: " + response.status.description);
        }

const model_version = response.model_version;
        console.log(JSON.stringify(model_version, null, 2));
    }
);

package com.clarifai.example;

public class ClarifaiExample {

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change these to your own model ID and version
    static final String MODEL_ID = "petsID";
    static final String MODEL_VERSION_ID = "7625a111b626438bb81a34c3b84d732f";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

SingleModelVersionResponse getModelVersionResponse = stub.getModelVersion(
            GetModelVersionRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .setVersionId(MODEL_VERSION_ID)
            .build()
        );

if (getModelVersionResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Get model version failed, status: " + getModelVersionResponse.getStatus());
        }

ModelVersion modelVersion = getModelVersionResponse.getModelVersion();
        System.out.println(modelVersion);

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the ID and version
// of the model we want to get its details. Change these strings to run your own example
///////////////////////////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change these to your own model ID and version
$MODEL_ID = "petsID";
$MODEL_VERSION_ID = "daf51b311c8644a486bbbe57c0680bc2";

use Clarifai\ClarifaiClient;
use Clarifai\Api\GetModelVersionRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->GetModelVersion(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new GetModelVersionRequest([\
            "user_app_id" => $userDataObject,\
            "model_id"=> $MODEL_ID,\
            "version_id" => $MODEL_VERSION_ID\
        ]),
        $metadata
    )->wait();

$modelVersion = $response->getModelVersion();
echo $modelVersion->serializeToJsonString();

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/versions/YOUR_MODEL_VERSION_ID_HERE" \
    -H "Authorization: Key YOUR_PAT_HERE"

Update

After creating a model, you can perform patch operations on it by merging, removing, or overwriting data. By default, all actions support overwriting, but they handle lists of objects in specific ways.

The merge action updates a key:value pair with key:new_value or appends to an existing list. For dictionaries, it merges entries that share the same id field.
The remove action is only used to delete the model's cover image on the platform UI.
The overwrite action completely replaces an existing object with a new one.

info

The PatchModels endpoint allows you to patch only the model level fields, and nothing in the model version. It only updates things like name, description, notes, and other metadata type information field you may have.
The PatchModelVersions endpoint allows you to change most of the model version fields like gettable, metadata, license, description, notes, and output_info (not including concepts).

Update Model Name

Let's use the PatchModels endpoint to change the model name to newname.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

#####################################################################################################
# In this section, we set the user authentication, app ID, and how we want to update the model.
# Change these strings to run your own example.
#####################################################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change these to update your own model
MODEL_ID = 'petsID'
MODEL_NAME = 'newname'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

patch_models_response = stub.PatchModels(
    service_pb2.PatchModelsRequest(
        user_app_id=userDataObject,
        action="overwrite",
        models=[\
            resources_pb2.Model(\
                id=MODEL_ID,\
                name=MODEL_NAME\
            )\
        ]
    ),
    metadata=metadata
)

if patch_models_response.status.code != status_code_pb2.SUCCESS:
    print(patch_models_response.status)
    raise Exception("Patch models failed, status: " + patch_models_response.status.description)

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and how we want to update the model.
    // Change these strings to run your own example.
    ////////////////////////////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change these to update your own model
    const MODEL_ID = 'petsID';
    const MODEL_NAME = 'newname';

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "models": [\
            {\
                "id": "petsID",\
                "name": MODEL_NAME\
            }\
        ],
        "action": "overwrite"
    });

const requestOptions = {
        method: 'PATCH',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        },
        body: raw
    };

fetch("https://api.clarifai.com/v2/models", requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and how we want to update the model.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.PatchModels(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        action: "overwrite",
        models: [\
            {\
                id: MODEL_ID,\
                name: MODEL_NAME\
            }\
        ]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Patch models failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

import com.clarifai.grpc.api.*;
import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;
import com.clarifai.grpc.api.status.StatusCode;

public class ClarifaiExample {

/////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and how we want to update the model.
    // Change these strings to run your own example.
    ////////////////////////////////////////////////////////////////////////////////////////////////////

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change these to update your own model
    static final String MODEL_ID = "petsID";
    static final String MODEL_NAME = "newname";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiModelResponse patchModelsResponse = stub.patchModels(
            PatchModelsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setAction("overwrite")
            .addModels(
                Model.newBuilder()
                .setId(MODEL_ID)
                .setName(MODEL_NAME)
            ).build()
        );

if (patchModelsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Patch models failed, status: " + patchModelsResponse.getStatus());
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

///////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and how we want to update the model.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change these to update your own model
$MODEL_ID = "petsID";
$MODEL_NAME = "newname";

use Clarifai\ClarifaiClient;
use Clarifai\Api\PatchModelsRequest;
use Clarifai\Api\Model;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->PatchModels(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new PatchModelsRequest([\
        "user_app_id" => $userDataObject,\
        "action" => "overwrite",\
        "models" => [\
            new Model([\
                "id" => $MODEL_ID,\
                "name" => $MODEL_NAME\
            ])\
        ]\
    ]),
    $metadata
)->wait();

?>

curl -X PATCH "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "models": [\
      {\
        "id": "petsID",\
        "name": "newname"\
      }\
    ],
    "action": "overwrite"
  }'

Update Model Configuration

Let's use the PatchModelVersions endpoint to configure the minimum probability threshold for the outputs we want to view from the model. We can modify the min_value parameter available for this model type to filter the outputs to see only the concepts with a probability score of 0.95 or higher.

tip

For embedding-classifiers, the min_value parameter falls within the range of 0 to 1, with a step size of 0.01. For most of the other model types, it falls within the range of 0 to 100, with a step size of 0.1.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

USER_ID = 'YOUR_USER_ID_HERE'

Your PAT (Personal Access Token) can be found in the Account's Security section

PAT = 'YOUR_PAT_HERE' APP_ID = 'YOUR_APP_ID_HERE'

Change these to update your own model

MODEL_ID = 'petsID' MODEL_VERSION_ID = 'b0b89c973e5d4b6d9599ce13da04b894' MINIMUM_VALUE = 0.95

from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel from clarifai_grpc.grpc.api import resources_pb2, service_pb2, service_pb2_grpc from clarifai_grpc.grpc.api.status import status_code_pb2 from google.protobuf.struct_pb2 import Struct

channel = ClarifaiChannel.get_grpc_channel() stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

params = Struct() params.update({ "min_value": MINIMUM_VALUE })

patch_models_response = stub.PatchModelVersions( service_pb2.PatchModelVersionsRequest( user_app_id=userDataObject, action="overwrite", model_id=MODEL_ID, model_versions=[
resources_pb2.ModelVersion(
id=MODEL_VERSION_ID,
output_info=resources_pb2.OutputInfo(
params=params
)
)
]

), metadata=metadata )

<!--index.html file-->

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change these to update your own model
    const MODEL_ID = 'petsID';
    const MODEL_VERSION_ID = 'b0b89c973e5d4b6d9599ce13da04b894';
    const MINIMUM_VALUE = 0.95;

const raw = JSON.stringify({
        "action": "overwrite",
        "model_versions":[{\
            "id": MODEL_VERSION_ID,\
            "output_info": {\
                "params": {\
                    "min_value": MINIMUM_VALUE\
                }\
            }\
        }]
    });

const requestOptions = {
        method: 'PATCH',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        },
        body: raw
    };

</script>

//index.js file

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.PatchModelVersions(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        action: "overwrite",
        model_id: MODEL_ID,
        model_versions:[{\
            "id": MODEL_VERSION_ID,\
            "output_info": {\
                "params": {\
                    "min_value": MINIMUM_VALUE\
                }\
            }\
        }],
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Patch models failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

import com.clarifai.grpc.api.*;
import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;
import com.clarifai.grpc.api.status.StatusCode;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;

public class ClarifaiExample {

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and how we want to update the model.
    // Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static final String USER_ID = "YOUR_USER_ID_HERE";
    // Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change these to update your own model
    static final String MODEL_ID = "petsID";
    static final String MODEL_VERSION_ID = "0b87504a8c1a47dc88b69ce63f4cf814";
    static final Double MINIMUM_VALUE = 0.95;

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
                .withCallCredentials(new ClarifaiCallCredentials(PAT));

Struct.Builder params = Struct.newBuilder()
                .putFields("min_value", Value.newBuilder().setNumberValue(MINIMUM_VALUE).build());

MultiModelVersionResponse patchModelsResponse = stub.patchModelVersions(
                PatchModelVersionsRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setAction("overwrite")
                        .setModelId(MODEL_ID)
                        .addModelVersions(ModelVersion.newBuilder()
                                .setId(MODEL_VERSION_ID)
                                .setOutputInfo(OutputInfo.newBuilder()
                                        .setParams(params)
                                )
                        )
                        .build()
        );

if (patchModelsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Post model outputs failed, status: " + patchModelsResponse.getStatus());
        }

}
}

<?php

require __DIR__ . "/vendor/autoload.php";

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change these to update your own model
$MODEL_ID = "petsID";
$MODEL_VERSION_ID = "b0b89c973e5d4b6d9599ce13da04b894";
$MINIMUM_VALUE = 0.95;

use Clarifai\ClarifaiClient;
use Clarifai\Api\PatchModelVersionsRequest;
use Clarifai\Api\ModelVersion;
use Clarifai\Api\OutputInfo;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;
use Google\Protobuf\Struct;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// create Struct instance
$params = new Struct();
$params->min_value = $MINIMUM_VALUE;

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->PatchModelVersions(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new PatchModelVersionsRequest([\
        "user_app_id" => $userDataObject,\
        "action" => "overwrite",\
        "model_id" => $MODEL_ID,\
        "model_versions" => [\
            new ModelVersion([\
                "id" => $MODEL_VERSION_ID,\
                "output_info" => new OutputInfo([\
                    "params" => $params\
                ])\
            ])\
        ]\
    ]),
    $metadata
)->wait();

?>

curl -X PATCH "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/versions" \
-H "Authorization: Key YOUR_PAT_HERE" \
-H "Content-Type: application/json" \
-d '{
  "model_versions": [\
    {\
      "id": "YOUR_MODEL_VERSION_ID_HERE",\
      "output_info": {\
          "params": {\
            "min_value": 0.95\
          }\
      }\
    }\
  ],
  "action": "overwrite"
}'

Other Patch Operations

Below is an example of performing other patch operations on a model, such as updating its description and notes.

Python SDK

from clarifai.client.app import App

app = App(app_id="YOUR_APP_ID_HERE", user_id="YOUR_USER_ID_HERE", pat="YOUR_PAT_HERE")

# Update the details of the model
app.patch_model(model_id="model_clusterer", action="merge", description="description", notes="notes", toolkits=["OpenAI"], use_cases=["llm"], languages=["en"], image_url="https://samples.clarifai.com/metro-north.jpg")

# Update the model's image by specifying the 'remove' action
app.patch_model(model_id='model_clusterer', action='remove', image_url='https://samples.clarifai.com/metro-north.jpg')

Search

Search Models by Name and Type

You can search all your models by name and type of model.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

################################################################
# In this section, we set the user authentication and app ID.
# Change these strings to run your own example.
#################################################################

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

post_models_searches_response = stub.PostModelsSearches(
    service_pb2.PostModelsSearchesRequest(
        user_app_id=userDataObject,
        model_query=resources_pb2.ModelQuery(
            name="gen*", # This supports wild card queries like "gen*" to match "general" as an example
            model_type_id="concept"
        )
    ),
    metadata=metadata
)

if post_models_searches_response.status.code != status_code_pb2.SUCCESS:
    print(post_models_searches_response.status)
    raise Exception("Post models searches failed, status: " + post_models_searches_response.status.description)

for model in post_models_searches_response.models:
    print(model)

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and app ID.
    // Change these strings to run your own example.
    /////////////////////////////////////////////////////////////////////

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "model_query": {
            "name": "gen*", //This supports wild card queries like "gen*" to match "general" as an example
            "model_type_id": "concept"
        }
    });

const requestOptions = {
        method: 'POST',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        },
        body: raw
    };

fetch("https://api.clarifai.com/v2/models/searches", requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));

</script>

//index.js file

////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and app ID.
// Change these strings to run your own example.
/////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.PostModelsSearches(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_query: {
            name: "gen*", //This supports wild card queries like "gen*" to match "general" as an example
            model_type_id: "concept"
        }
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Post model searches failed, status: " + response.status.description);
        }

const models = response.models;
        for (const model of models) {
            console.log(JSON.stringify(model, null, 2));
        }
    }
);

package com.clarifai.example;

public class ClarifaiExample {

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

MultiModelResponse postModelsSearchesResponse = stub.postModelsSearches(
            PostModelsSearchesRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelQuery(
                ModelQuery.newBuilder()
                .setName("gen*") // This supports wild card queries like "gen*" to match "general" as an example
                .setModelTypeId("concept")
            )
            .build()
        );

if (postModelsSearchesResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Post models searches failed, status: " + postModelsSearchesResponse.getStatus());
        }

List<Model> models = postModelsSearchesResponse.getModelsList();
        for (Model model : models) {
            System.out.println(model);
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and app ID.
// Change these strings to run your own example.
///////////////////////////////////////////////////////////////////////////////

use Clarifai\ClarifaiClient;
use Clarifai\Api\PostModelsSearchesRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;
use Clarifai\Api\ModelQuery;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->PostModelsSearches(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new PostModelsSearchesRequest([\
        "user_app_id" => $userDataObject,\
        "model_query" => new ModelQuery([\
            "name" => "gen*", // This supports wild card queries like "gen*" to match "general" as an example\
            "model_type_id" => "concept"\
        ])\
    ]),
    $metadata
)->wait();

foreach ($response->getModels() as $model) {
    echo $model->serializeToJsonString() . "\n";
}

?>

# "gen*" supports wild card queries like "gen*" to match "general" as an example

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/searches" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "model_query": {
      "name": "gen*",
      "model_type_id": "concept"
    }
  }'

Delete

Delete a Model

You can delete a model by using the model_id parameter.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

##########################################################################
# In this section, we set the user authentication, app ID, and model ID.
# Change these strings to run your own example.
##########################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change this to your own model ID
MODEL_ID = 'petsID'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

delete_model_response = stub.DeleteModel(
    service_pb2.DeleteModelRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID
    ),
    metadata=metadata
)

if delete_model_response.status.code != status_code_pb2.SUCCESS:
    print(delete_model_response.status)
    raise Exception("Delete model inputs failed, status: " + delete_model_response.status.description)

<!--index.html file-->

<script>
    //////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and model ID.
    // Change these strings to run your own example.
    //////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change this to your own model ID
    const MODEL_ID = 'petsID';

const requestOptions = {
        method: 'DELETE',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

</script>

//index.js file

//////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and model ID.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.DeleteModel(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Delete model failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

import com.clarifai.grpc.api.*;
import com.clarifai.grpc.api.status.BaseResponse;
import com.clarifai.grpc.api.status.StatusCode;
import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;

public class ClarifaiExample {

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change this to your own model ID
    static final String MODEL_ID = "petsID";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

BaseResponse deleteModelResponse = stub.deleteModel(
            DeleteModelRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .build()
        );

if (deleteModelResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Delete model failed, status: " + deleteModelResponse.getStatus());
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and model ID.
// Change these strings to run your own example.
////////////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change this to your own model ID
$MODEL_ID = "petsID";

use Clarifai\ClarifaiClient;
use Clarifai\Api\DeleteModelRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->DeleteModel(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new DeleteModelRequest([\
        "user_app_id" => $userDataObject,\
        "model_id" => $MODEL_ID\
    ]),
    $metadata
)->wait();

?>

curl -X DELETE "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE" \
    -H "Authorization: Key YOUR_PAT_HERE"

Delete a Model Version

You can also delete a specific version of a model with the model_id and version_id parameters.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

##################################################################################
# In this section, we set the user authentication, app ID, and the ID and version
# of the model we want to delete. Change these strings to run your own example.
##################################################################################

USER_ID = 'YOUR_USER_ID_HERE'
# Your PAT (Personal Access Token) can be found in the Account's Security section
PAT = 'YOUR_PAT_HERE'
APP_ID = 'YOUR_APP_ID_HERE'
# Change these to your own model ID and version
MODEL_ID = 'petsID'
MODEL_VERSION_ID = '9641cbbb019b424db17e593b48ebc7ff'

channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

delete_model_version_response = stub.DeleteModelVersion(
    service_pb2.DeleteModelVersionRequest(
        user_app_id=userDataObject,
        model_id=MODEL_ID,
        version_id=MODEL_VERSION_ID
    ),
    metadata=metadata
)

if delete_model_version_response.status.code != status_code_pb2.SUCCESS:
    print(delete_model_version_response.status)
    raise Exception("Delete model version failed, status: " + delete_model_version_response.status.description)

<!--index.html file-->

<script>
    /////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the ID and version
    // of the model we want to delete. Change these strings to run your own example.
    /////////////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
    // Your PAT (Personal Access Token) can be found in the Account's Security section
    const PAT = 'YOUR_PAT_HERE';
    const APP_ID = 'YOUR_APP_ID_HERE';
    // Change these to your own model ID and version
    const MODEL_ID = 'petsID';
    const MODEL_VERSION_ID = '090d937cdf11489f8c3d0b76b61a5fc5';

const requestOptions = {
        method: 'DELETE',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        }
    };

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/models/${MODEL_ID}/versions/${MODEL_VERSION_ID}`, requestOptions)
        .then(response => response.text())
        .then(result => console.log(result))
        .catch(error => console.log('error', error));
</script>

//index.js file

/////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the ID and version
// of the model we want to delete. Change these strings to run your own example.
/////////////////////////////////////////////////////////////////////////////////////

const USER_ID = 'YOUR_USER_ID_HERE';
// Your PAT (Personal Access Token) can be found in the Account's Security section
const PAT = 'YOUR_PAT_HERE';
const APP_ID = 'YOUR_APP_ID_HERE';
// Change these to your own model ID and version
const MODEL_ID = 'petsID';
const MODEL_VERSION_ID = '304ae281b04349e5ae51d11be10ed95a';

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.DeleteModelVersion(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        model_id: MODEL_ID,
        version_id: MODEL_VERSION_ID
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Delete model version failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

public class ClarifaiExample {

static final String USER_ID = "YOUR_USER_ID_HERE";
    //Your PAT (Personal Access Token) can be found in the portal under Authentication
    static final String PAT = "YOUR_PAT_HERE";
    static final String APP_ID = "YOUR_APP_ID_HERE";
    // Change these to your own model ID and version
    static final String MODEL_ID = "petsID";
    static final String MODEL_VERSION_ID = "304ae281b04349e5ae51d11be10ed95a";

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

BaseResponse deleteModelVersionResponse = stub.deleteModelVersion(
            DeleteModelVersionRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setModelId(MODEL_ID)
            .setVersionId(MODEL_VERSION_ID)
            .build()
        );

if (deleteModelVersionResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Delete model version failed, status: " + deleteModelVersionResponse.getStatus());
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

///////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the ID and version
// of the model we want to delete. Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////////////////////

$USER_ID = "YOUR_USER_ID_HERE";
// Your PAT (Personal Access Token) can be found in the Account's Security section
$PAT = "YOUR_PAT_HERE";
$APP_ID = "YOUR_APP_ID_HERE";
// Change these to your own model ID and version
$MODEL_ID = "petsID";
$MODEL_VERSION_ID = "6c0effb1efff40e3add11afd2aa35375";

use Clarifai\ClarifaiClient;
use Clarifai\Api\DeleteModelVersionRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->DeleteModelVersion(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new DeleteModelVersionRequest([\
        "user_app_id" => $userDataObject,\
        "model_id" => $MODEL_ID,\
        "version_id" => $MODEL_VERSION_ID\
    ]),
    $metadata
)->wait();

?>

curl -X DELETE "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/YOUR_MODEL_ID_HERE/versions/YOUR_MODEL_VERSION_ID_HERE" \
    -H "Authorization: Key YOUR_PAT_HERE"

Delete all Models

If you would like to delete all models associated with an application, you can also do that.

caution

Please proceed with extreme caution as deleted models cannot be recovered.

Python (gRPC)
JavaScript (REST)
Node.js (gRPC)
Java (gRPC)
PHP (gRPC)
cURL

channel = ClarifaiChannel.get_grpc_channel() stub = service_pb2_grpc.V2Stub(channel)

metadata = (('authorization', 'Key ' + PAT),)

userDataObject = resources_pb2.UserAppIDSet(user_id=USER_ID, app_id=APP_ID)

delete_models_response = stub.DeleteModels( service_pb2.DeleteModelsRequest( user_app_id=userDataObject, delete_all=True ), metadata=metadata )

if delete_models_response.status.code != status_code_pb2.SUCCESS: print(delete_models_response.status) raise Exception("Delete models failed, status: " + delete_models_response.status.description)


```javascript
<!--index.html file-->

<script>
    ///////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication and app ID.
    // Change these strings to run your own example.
    ///////////////////////////////////////////////////////////////////////////

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        delete_all: true
    });

const requestOptions = {
        method: 'DELETE',
        headers: {
            'Accept': 'application/json',
            'Authorization': 'Key ' + PAT
        },
        body: raw
    };

</script>

//index.js file

//////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication and app ID.
// Change these strings to run your own example.
//////////////////////////////////////////////////////////////////////

const { ClarifaiStub, grpc } = require("clarifai-nodejs-grpc");

const stub = ClarifaiStub.grpc();

// This will be used by every Clarifai endpoint call
const metadata = new grpc.Metadata();
metadata.set("authorization", "Key " + PAT);

stub.DeleteModels(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        delete_all: true
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Delete models failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

public class ClarifaiExample {

public static void main(String[] args) {

V2Grpc.V2BlockingStub stub = V2Grpc.newBlockingStub(ClarifaiChannel.INSTANCE.getGrpcChannel())
            .withCallCredentials(new ClarifaiCallCredentials(PAT));

BaseResponse deleteModelsResponse = stub.deleteModels(
            DeleteModelsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .setDeleteAll(true)
            .build()
        );

if (deleteModelsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Delete models failed, status: " + deleteModelsResponse.getStatus());
        }

}

}

<?php

require __DIR__ . "/vendor/autoload.php";

use Clarifai\ClarifaiClient;
use Clarifai\Api\DeleteModelsRequest;
use Clarifai\Api\Status\StatusCode;
use Clarifai\Api\UserAppIDSet;

$client = ClarifaiClient::grpc();

$metadata = ["Authorization" => ["Key " . $PAT]];

$userDataObject = new UserAppIDSet([\
    "user_id" => $USER_ID,\
    "app_id" => $APP_ID,\
]);

// Let's make a RPC call to the Clarifai platform. It uses the opened gRPC client channel to communicate a
// request and then wait for the response
[$response, $status] = $client->DeleteModels(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new DeleteModelsRequest([\
        "user_app_id" => $userDataObject,\
        "delete_all" => true\
    ]),
    $metadata
)->wait();

?>

curl -X DELETE "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/models/" \
    -H "Authorization: Key YOUR_PAT_HERE" \
    -d '{
        "delete_all": true
    }'

Build your next AI app, test and tune popular LLMs models, and much more.

Get started for free

Get ​

List Model Types ​

List Models ​

Get Model by ID ​

Get Model Output Info by ID ​

List Model Concepts ​

List Model Versions ​

Get Model Version by ID ​

Update ​

Update Model Name ​

Update Model Configuration ​

Your PAT (Personal Access Token) can be found in the Account's Security section

Change these to update your own model

Other Patch Operations ​

Search ​

Search Models by Name and Type ​

Delete ​

Delete a Model ​

Delete a Model Version ​

Delete all Models ​

Get

List Model Types

List Models

Get Model by ID

Get Model Output Info by ID

List Model Concepts

List Model Versions

Get Model Version by ID

Update

Update Model Name

Update Model Configuration

Other Patch Operations

Search

Search Models by Name and Type

Delete

Delete a Model

Delete a Model Version

Delete all Models