Upload via API | Clarifai Docs

Skip to main content

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

On this page

Add data to the Clarifai platform via the API

Data Utils

The Clarifai's Data Utils library allows you to effortlessly extract, transform, and load unstructured data — such as images, videos, and text — into the Clarifai platform.

info

Before using the Python SDK, 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.

Note that input uploads are processed asynchronously. Your files will be indexed in the background via your app's default base workflow, which may take some time depending on volume and file types.

To verify successful indexing, you can check the input status for code 30000 (INPUT_IMAGE_DOWNLOAD_SUCCESS). This confirms the input is fully processed and ready for use.

Upload Image Data ​

Below is an example of how to upload image data.

from clarifai.client.input import Inputs

img_url = "https://samples.clarifai.com/metro-north.jpg"
input_obj = Inputs(user_id="user_id", app_id="test_app", pat="YOUR_PAT")
# You can also upload data through Bytes and Filepath,

# Upload from file
# input_obj.upload_from_file(input_id='demo', image_file=’image_filepath')

# Upload from bytes
# input_obj.upload_from_bytes(input_id='demo', image_bytes=image)

input_obj.upload_from_url(input_id="demo", image_url=img_url)

Output


2024-01-15 16:38:49 INFO     clarifai.client.input:                                                    input.py:669

Inputs Uploaded

code: SUCCESS

description: "Ok"

details: "All inputs successfully added"

req_id: "a14eda72951b06cd25561381d70ced74"

import { Input } from "clarifai-nodejs";

const imageUrl = "https://samples.clarifai.com/metro-north.jpg";
const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
await input.uploadFromUrl({
  inputId: "demo",
  imageUrl,
});

Upload Text Data ​

Below is an example of how to upload text data.

from clarifai.client.input import Inputs

input_text = b"Write a tweet on future of AI"
input_obj = Inputs(user_id="user_id", app_id="test_app", pat="YOUR_PAT")

# You can also upload data through URLand Filepath,

# Upload from file
# input_obj.upload_from_file(input_id='text_dat', text_file=’text_filepath')

# Upload from url
# input_obj.upload_from_url(input_id='text,text_url=”text_url”)

input_obj.upload_from_bytes(input_id="text_data", text_bytes=input_text)

Output

2024-01-16 14:14:41 INFO     clarifai.client.input:                                                    input.py:669

Inputs Uploaded

code: SUCCESS

description: "Ok"

details: "All inputs successfully added"

req_id: "80d2454a1dea0411e20fb03b2fe0c8b1"

import { Input } from "clarifai-nodejs";

const inputText = "Write a tweet on future of AI";
const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
input.uploadText({
  inputId: "text_data",
  rawText: inputText,
});

Write Custom Functions for Data Processing ​

You can add your own custom functions for data processing with ease.

Below is an example of how to clean text data by removing Unicode characters before uploading it to the Clarifai platform.

from clarifai.client.input import Inputs

# Initialize the Inputs object with user and app IDs
input_object = Inputs(user_id="YOUR_USER_ID_HERE", app_id="YOUR_APP_ID_HERE", pat="YOUR_PAT_HERE")

# Remove unicode from text
def remove_unicode_and_upload(input_id, text):
    string_encode = text.encode("ascii", "ignore")
    string_decode = string_encode.decode()
    input_object.upload_text(input_id=input_id,raw_text=string_decode)

remove_unicode_and_upload(input_id='test', text="This is a test \u200c example. ")

Upload Audio Data ​

Below is an example of how to upload audio data.

from clarifai.client.input import Inputs

audio_url = "https://s3.amazonaws.com/samples.clarifai.com/GoodMorning.wav"
input_obj = Inputs(user_id="user_id", app_id="test_app", pat="YOUR_PAT")

# You can also upload data through Bytes and Filepath,

# Upload from file
# input_obj.upload_from_file(input_id='audio_data', audio_file=’audio_filepath')

# Upload from bytes
# input_obj.upload_from_bytes(input_id='audio_data’, audio_bytes=audio)

input_obj.upload_from_url(
    input_id="audio_data",
    audio_url=audio_url,
)

Output


2024-01-16 14:18:58 INFO     clarifai.client.input:                                                    input.py:669

Inputs Uploaded

code: SUCCESS

description: "Ok"

details: "All inputs successfully added"

req_id: "c16d3dd066d7ee48d038744daacef6e8"

import { Input } from "clarifai-nodejs";

const audioUrl =
  "https://s3.amazonaws.com/samples.clarifai.com/GoodMorning.wav";
const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
input.uploadFromUrl({
  inputId: "audio_data",
  audioUrl,
});

Upload Video Data ​

Below is an example of how to upload video data.

from clarifai.client.input import Inputs
video_url = "https://samples.clarifai.com/beer.mp4"
input_obj = Inputs(user_id="user_id", app_id="test_app", pat="YOUR_PAT")

# You can also upload data through Bytes and Filepath,

# Upload from file
# input_obj.upload_from_file(input_id='video_data', video_file=’video_filepath')

# Upload from bytes
# input_obj.upload_from_bytes(input_id='video_data’, video_bytes=video)

input_obj.upload_from_url(
    input_id="video_data", video_url= video_url
)

Output

2024-01-16 14:25:26 INFO     clarifai.client.input:                                                    input.py:669

Inputs Uploaded

code: SUCCESS

description: "Ok"

details: "All inputs successfully added"

req_id: "00576d040a6254019942ab4eceb306ad"

import { Input } from "clarifai-nodejs";

const videoUrl = "https://samples.clarifai.com/beer.mp4";
const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
await input.uploadFromUrl({
  inputId: "video_data",
  videoUrl,
});

Upload Multimodal Data ​

Below is an example of how to upload a combination of different input types, such as images and text, to the Clarifai platform.

Currently, Clarifai supports specific multimodal input combinations, such as [Image, Text] -> Text. This allows you to process and analyze interconnected data types for advanced use cases.

from clarifai.client.input import Inputs

input_obj = Inputs(user_id="user_id", app_id="test_app", pat="YOUR_PAT")

# initialize inputs of different type
prompt = "What time of day is it?"
image_url = "https://samples.clarifai.com/metro-north.jpg"

# Here you can give the value for different types of inputs
input_obj.get_multimodal_input(
    input_id="multimodal_data", image_url=image_url, raw_text=prompt
)

Output

id: "multimodal_data"
data {
  image {
    url: "https://samples.clarifai.com/metro-north.jpg"
  }
  text {
    raw: "What time of day is it?"
  }
}

import { Input } from "clarifai-nodejs";

const prompt = "What time of day is it?";
const imageUrl = "https://samples.clarifai.com/metro-north.jpg";
const multimodalInput = Input.getMultimodalInput({
  inputId: "multimodal_data",
  imageUrl,
  rawText: prompt,
});
console.log(multimodalInput);

Upload Custom Metadata ​

When using the Clarifai SDKs, you can enhance your inputs by attaching custom metadata alongside concepts. This feature enables you to include additional contextual information, such as categorization, filtering criteria, or reference data, making it easier to organize and retrieve your inputs later.

Below are examples of how to upload inputs with custom metadata. In these examples, the metadata includes details about the filename and the dataset split (e.g., train, validate, or test) to which the input belongs.

Image With Metadata ​

# Import necessary modules
from google.protobuf.struct_pb2 import Struct
from clarifai.client.input import Inputs

# Create an Inputs object with user_id and app_id
input_object = Inputs(user_id="user_id", app_id="app_id", pat="YOUR_PAT")

# Create a Struct object for metadata
metadata = Struct()

# Update metadata with filename and split information
metadata.update({"filename": "XiJinping.jpg", "split": "train"})

# URL of the image to upload
url = "https://samples.clarifai.com/XiJinping.jpg"

# Upload the image from the URL with associated metadata
input_object.upload_from_url(input_id="metadata", image_url=url, metadata=metadata)

Output

2024-04-05 13:03:24 INFO     clarifai.client.input:                                                    input.py:674
                             Inputs Uploaded
                             code: SUCCESS
                             description: "Ok"
                             details: "All inputs successfully added"
                             req_id: "951a64b950cccf05c8d274c8acc1f0f6"

INFO:clarifai.client.input:
Inputs Uploaded
code: SUCCESS
description: "Ok"
details: "All inputs successfully added"
req_id: "951a64b950cccf05c8d274c8acc1f0f6"

('8557e0f57f464c22b3483de76757fb4f',
 status {
   code: SUCCESS
   description: "Ok"
   details: "All inputs successfully added"
   req_id: "951a64b950cccf05c8d274c8acc1f0f6"
 }
 inputs {
   id: "metadata"
   data {
     image {
       url: "https://samples.clarifai.com/XiJinping.jpg"
       image_info {
         format: "UnknownImageFormat"
         color_mode: "UnknownColorMode"
       }
     }
     metadata {
       fields {
         key: "filename"
         value {
           string_value: "XiJinping.jpg"
         }
       }
       fields {
         key: "split"
         value {
           string_value: "train"
         }
       }
     }
   }
   created_at {
     seconds: 1712322204
     nanos: 737881425
   }
   modified_at {
     seconds: 1712322204
     nanos: 737881425
   }
   status {
     code: INPUT_DOWNLOAD_PENDING
     description: "Download pending"
   }
 }
 inputs_add_job {
   id: "8557e0f57f464c22b3483de76757fb4f"
   progress {
     pending_count: 1
   }
   created_at {
     seconds: 1712322204
     nanos: 714751000
   }
   modified_at {
     seconds: 1712322204
     nanos: 714751000
   }
   status {
     code: JOB_QUEUED
     description: "Job is queued to be ran."
   }
 })

import { Input } from "clarifai-nodejs";

const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
const metadata = {
  filename: "XiJinping.jpg",
  split: "train",
};
const imageUrl = "https://samples.clarifai.com/XiJinping.jpg";
await input.uploadFromUrl({
  inputId: "image_with_metadata",
  imageUrl,
  metadata,
});

Video With Metadata ​

from google.protobuf.struct_pb2 import Struct
from clarifai.client.input import Inputs

# Initialize an Inputs object with specified user_id and app_id
input_object = Inputs(user_id="user_id", app_id="app_id", pat="YOUR_PAT")

# Define the URL of the video to upload
video_url = "https://samples.clarifai.com/beer.mp4"

# Create a Struct object to hold metadata
metadata = Struct()

# Update the metadata with filename and split information
metadata.update({"filename": "drinks.jpg", "split": "train"})

# Upload the video from the specified URL with the provided metadata
input_object.upload_from_url(
    input_id="video_data_metadata", video_url=video_url, metadata=metadata
)

Output

2024-04-05 13:05:49 INFO     clarifai.client.input:                                                    input.py:674
                             Inputs Uploaded
                             code: SUCCESS
                             description: "Ok"
                             details: "All inputs successfully added"
                             req_id: "72c9820d805efb9f3ee7f0508778c1f3"

INFO:clarifai.client.input:
Inputs Uploaded
code: SUCCESS
description: "Ok"
details: "All inputs successfully added"
req_id: "72c9820d805efb9f3ee7f0508778c1f3"

('7fdc30b9c2a24f31b6a41b32bd9fea02',
 status {
   code: SUCCESS
   description: "Ok"
   details: "All inputs successfully added"
   req_id: "72c9820d805efb9f3ee7f0508778c1f3"
 }
 inputs {
   id: "video_data_metadata"
   data {
     video {
       url: "https://samples.clarifai.com/beer.mp4"
       video_info {
         video_format: "UnknownVideoFormat"
       }
     }
     metadata {
       fields {
         key: "filename"
         value {
           string_value: "drinks.jpg"
         }
       }
       fields {
         key: "split"
         value {
           string_value: "train"
         }
       }
     }
   }
   created_at {
     seconds: 1712322349
     nanos: 628288634
   }
   modified_at {
     seconds: 1712322349
     nanos: 628288634
   }
   status {
     code: INPUT_DOWNLOAD_PENDING
     description: "Download pending"
   }
 }
 inputs_add_job {
   id: "7fdc30b9c2a24f31b6a41b32bd9fea02"
   progress {
     pending_count: 1
   }
   created_at {
     seconds: 1712322349
     nanos: 602487000
   }
   modified_at {
     seconds: 1712322349
     nanos: 602487000
   }
   status {
     code: JOB_QUEUED
     description: "Job is queued to be ran."
   }
 })

import { Input } from "clarifai-nodejs";

const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
const metadata = {
  filename: "beer.mp4",
  split: "train",
};
const videoUrl = "https://samples.clarifai.com/beer.mp4";
await input.uploadFromUrl({
  inputId: "video_data_metadata",
  videoUrl,
  metadata,
});

Text With Metadata ​

# Import necessary modules
from google.protobuf.struct_pb2 import Struct
from clarifai.client.input import Inputs

# Define the input object with user_id and app_id
input_object = Inputs(user_id="user_id", app_id="app_id", pat="YOUR_PAT")

# Define the input text
input_text = b"Write a tweet on future of AI"

# Create a Struct object for metadata
metadata = Struct()

# Update metadata with filename and split information
metadata.update({"filename": "tweet.txt", "split": "train"})

# Upload the input from bytes with custom metadata
input_object.upload_from_bytes(input_id="text_data_metadata", text_bytes=input_text, metadata=metadata)

Output

2024-04-05 13:07:04 INFO     clarifai.client.input:                                                    input.py:674
                             Inputs Uploaded
                             code: SUCCESS
                             description: "Ok"
                             details: "All inputs successfully added"
                             req_id: "835f6c736f032947d1f4067e39c10b72"

INFO:clarifai.client.input:
Inputs Uploaded
code: SUCCESS
description: "Ok"
details: "All inputs successfully added"
req_id: "835f6c736f032947d1f4067e39c10b72"

('e3de274f644a4e98a488e7c85f94c0d1',
 status {
   code: SUCCESS
   description: "Ok"
   details: "All inputs successfully added"
   req_id: "835f6c736f032947d1f4067e39c10b72"
 }
 inputs {
   id: "text_data_metadata"
   data {
     metadata {
       fields {
         key: "filename"
         value {
           string_value: "tweet.txt"
         }
       }
       fields {
         key: "split"
         value {
           string_value: "train"
         }
       }
     }
     text {
       url: "https://data.clarifai.com/orig/users/8tzpjy1a841y/apps/visual_classifier_eval/inputs/text/c439598b04d8112867eec70097aa00c2"
       text_info {
         encoding: "UnknownTextEnc"
       }
     }
   }
   created_at {
     seconds: 1712322424
     nanos: 56818659
   }
   modified_at {
     seconds: 1712322424
     nanos: 56818659
   }
   status {
     code: INPUT_DOWNLOAD_PENDING
     description: "Download pending"
   }
 }
 inputs_add_job {
   id: "e3de274f644a4e98a488e7c85f94c0d1"
   progress {
     pending_count: 1
   }
   created_at {
     seconds: 1712322423
     nanos: 941401000
   }
   modified_at {
     seconds: 1712322423
     nanos: 941401000
   }
   status {
     code: JOB_QUEUED
     description: "Job is queued to be ran."
   }
 })

import { Input } from "clarifai-nodejs";

const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
const textBytes = Buffer.from("Write a tweet on future of AI");
const metadata = {
  filename: "tweet.txt",
  split: "train",
};
await input.uploadFromBytes({
  inputId: "text_with_metadata",
  textBytes,
  metadata,
});

Audio With Metadata ​

# Import necessary modules
from clarifai.client.input import Inputs
from google.protobuf.struct_pb2 import Struct

# Define the input object with user_id and app_id
input_object = Inputs(user_id="user_id", app_id="app_id", pat="YOUR_PAT")

# Define the URL of the audio file
audio_url = "https://s3.amazonaws.com/samples.clarifai.com/GoodMorning.wav"

# Create a new Struct to hold metadata
metadata = Struct()

# Update the metadata with filename and split information
metadata.update({"filename": "goodmorning.wav", "split": "test"})

# Upload the input from the specified URL with metadata
input_object.upload_from_url(
    input_id="audio_data_metadata",  # Specify an ID for the input
    audio_url=audio_url,  # URL of the audio file
    metadata=metadata  # Custom metadata associated with the input
)

Output

2024-04-08 06:39:32 INFO     clarifai.client.input:                                                    input.py:674
                             Inputs Uploaded
                             code: SUCCESS
                             description: "Ok"
                             details: "All inputs successfully added"
                             req_id: "4c96e4167170c174838c7987101f3478"

INFO:clarifai.client.input:
Inputs Uploaded
code: SUCCESS
description: "Ok"
details: "All inputs successfully added"
req_id: "4c96e4167170c174838c7987101f3478"

('109349aa790a404db39f6324415a47a5',
 status {
   code: SUCCESS
   description: "Ok"
   details: "All inputs successfully added"
   req_id: "4c96e4167170c174838c7987101f3478"
 }
 inputs {
   id: "audio_data_metadata"
   data {
     metadata {
       fields {
         key: "filename"
         value {
           string_value: "goodmorning.wav"
         }
       }
       fields {
         key: "split"
         value {
           string_value: "test"
         }
       }
     }
     audio {
       url: "https://s3.amazonaws.com/samples.clarifai.com/GoodMorning.wav"
       audio_info {
         audio_format: "UnknownAudioFormat"
       }
     }
   }
   created_at {
     seconds: 1712558372
     nanos: 764691920
   }
   modified_at {
     seconds: 1712558372
     nanos: 764691920
   }
   status {
     code: INPUT_DOWNLOAD_PENDING
     description: "Download pending"
   }
 }
 inputs_add_job {
   id: "109349aa790a404db39f6324415a47a5"
   progress {
     pending_count: 1
   }
   created_at {
     seconds: 1712558372
     nanos: 751997000
   }
   modified_at {
     seconds: 1712558372
     nanos: 751997000
   }
   status {
     code: JOB_QUEUED
     description: "Job is queued to be ran."
   }
 })

import { Input } from "clarifai-nodejs";

const input = new Input({
  authConfig: {
    userId: process.env.CLARIFAI_USER_ID,
    pat: process.env.CLARIFAI_PAT,
    appId: "test_app",
  },
});
const metadata = {
  filename: "goodmorning.wav",
  split: "test",
};
const audioUrl =
  "https://s3.amazonaws.com/samples.clarifai.com/GoodMorning.wav";
await input.uploadFromUrl({
  inputId: "audio_data_metadata",
  audioUrl,
  metadata,
});

Upload Inputs with Geospatial Information ​

When uploading inputs to Clarifai, you can enrich them by including geospatial data, such as longitude and latitude coordinates from the GPS system.

This allows you to associate each input with a specific geographic location. Note that each input can have at most one geospatial point associated with it.

from clarifai.client.input import Inputs

# URL of the image to upload
image_url = "https://samples.clarifai.com/Ferrari.jpg"

# Provide the Geoinfo to be added to the input
# geo_info=[longitude, latitude]
geo_points = [102,73]

# Create an Inputs object with user_id and app_id
input_object = Inputs(user_id="YOUR_USER_ID_HERE", app_id="YOUR_APP_ID_HERE", pat="YOUR_PAT_HERE")

# Upload the image from the URL with associated GeoInfo
input_object.upload_from_url(input_id="geo_info", image_url=image_url, geo_info=geo_points)

Upload Inputs With Annotations ​

You can upload inputs along with their corresponding annotations, such as bounding boxes or polygons.

Bounding Box Annotations ​

Below is an example of how to label a new rectangular bounding box for a specific region within an image. The bounding box coordinates should be normalized to the image dimensions, with values scaled to the range of [0, 1.0].

This ensures that the coordinates are independent of the image resolution, making the annotations consistent across different image sizes.

# Start by uploading the image with a specific input ID as described earlier
# For example, you can upload this image: https://samples.clarifai.com/BarackObama.jpg
# Then, after successfully uploading it, apply the bounding box annotations

from clarifai.client.input import Inputs

# Initialize the Inputs object with user and app IDs
input_object = Inputs(user_id="YOUR_USER_ID_HERE", app_id="YOUR_APP_ID_HERE", pat="YOUR_PAT_HERE")

# Upload bounding box annotations
bbox_points = [.1, .1, .8, .9]  # Coordinates of the bounding box
annotation = input_object.get_bbox_proto(input_id="bbox", label="face", bbox=bbox_points, label_id="id-face", annot_id="demo")
input_object.upload_annotations([annotation])

Polygon Annotations ​

Below is an example of how to annotate any polygon-shaped region within an image.

A polygon is defined by a list of points, each specified by:

# Start by uploading the image with a specific input ID as described earlier
# For example, you can upload this image: https://samples.clarifai.com/airplane.jpeg
# Then, after successfully uploading it, apply the polygon annotations

from clarifai.client.input import Inputs

# Initialize the Inputs object with user and app IDs
input_object = Inputs(user_id="YOUR_USER_ID_HERE", app_id="YOUR_APP_ID_HERE", pat="YOUR_PAT_HERE")

# Upload polygon annotations
#polygons=[[[x,y],...,[x,y]],...]
polygon_pts = [[.15,.24],[.4,.78],[.77,.62],[.65,.15]]
annotation = input_object.get_mask_proto(input_id="mask", label="airplane", polygons=polygon_pts)
input_object.upload_annotations([annotation])

Concepts Annotations ​

Below is an example of how to annotate different types of inputs with concepts.

from clarifai.client.input import Inputs

url = "https://samples.clarifai.com/featured-models/Llama2_Conversational-agent.txt"

# Change this depending on the type of input you want to annotate
concepts = ["mobile","camera"]

# Initialize the Inputs object with user and app IDs
input_object = Inputs(user_id="YOUR_USER_ID_HERE", app_id="YOUR_APP_ID_HERE", pat="YOUR_PAT_HERE")

# Upload text data with concepts
input_object.upload_from_url(input_id="text1", text_url=url, labels=concepts)

# Upload image data with concepts
#input_object.upload_from_url(input_id="image1", image_url="ADD_URL_HERE", labels=concepts)

# Upload video data with concepts
#input_object.upload_from_url(input_id="video1", video_url="ADD_URL_HERE", labels=concepts)

# Upload audio data with concepts
#input_object.upload_from_url(input_id="audio1", audio_url="ADD_URL_HERE", labels=concepts)

Upload Inputs Options (via URLs, bytes, concepts, metadata, etc) ​

You can add inputs one by one or in bulk. If you send them in bulk, you are limited to sending 128 inputs at a time, as mentioned above.

Upload Inputs via URL ​

Below is an example of how to add inputs via a publicly accessible URL.

##########################################################################
# In this section, we set the user authentication, app ID, and input URL.
# 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 image input you want to add
IMAGE_URL = 'https://samples.clarifai.com/metro-north.jpg'

##########################################################################
# 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)

post_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL,\
                        allow_duplicate_url=True\
                    )\
                )\
            )\
        ]
    ),
    metadata=metadata
)

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

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and input URL.
    // 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 image input you want to add
    const IMAGE_URL = 'https://samples.clarifai.com/metro-north.jpg';

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

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL,\
                        "allow_duplicate_url": true\
                    }\
                }\
            }\
        ]
    });

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

fetch("https://api.clarifai.com/v2/inputs", 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 input URL.
// 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.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        inputs: [\
            { data: { image: { url: IMAGE_URL, allow_duplicate_url: true } } }\
        ]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            console.log(response.status);
            throw new Error("Post inputs 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.*;

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 image input you want to add
    static final String IMAGE_URL = "https://samples.clarifai.com/metro-north.jpg";

public static void main(String[] args) {

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

MultiInputResponse postInputsResponse = stub.postInputs(
            PostInputsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .addInputs(
                Input.newBuilder().setData(
                    Data.newBuilder().setImage(
                        Image.newBuilder()
                        .setUrl(IMAGE_URL)
                        .setAllowDuplicateUrl(true)
                    )
                )
            ).build()
        );

if (postInputsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Post inputs failed, status: " + postInputsResponse.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 this to whatever image input you want to add
$IMAGE_URL = 'https://samples.clarifai.com/metro-north.jpg';

use Clarifai\ClarifaiClient;
use Clarifai\Api\Data;
use Clarifai\Api\Image;
use Clarifai\Api\Input;
use Clarifai\Api\PostInputsRequest;
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->PostInputs(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new PostInputsRequest([\
        'user_app_id' => $userDataObject,\
        'inputs' => [\
            new Input([ // The Input object wraps the Data object in order to meet the API specification\
                'data' => new Data([ // The Data object is constructed around the Image object. It offers a container that has additional image independent\
                                    // metadata. In this particular use case, no other metadata is needed to be specified\
                    'image' => new Image([ // In the Clarifai platform, an image is defined by a special Image object\
                        'url' => $IMAGE_URL,\
                        'allow_duplicate_url' => true\
                    ])\
                ])\
            ])\
        ]\
    ]),
    $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());
}

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [\
      {\
        "data": {\
          "image": {\
            "url": "https://samples.clarifai.com/metro-north.jpg",\
            "allow_duplicate_url": true\
          }\
        }\
      }\
    ]
  }'

Upload Inputs via Bytes ​

Below is an example of how to add inputs via bytes.

Note

The data must be base64 encoded. When you add a base64 image to our servers, a copy will be stored and hosted on our servers. If you already have an image hosting service, we recommend using it and adding images via the url parameter.

##################################################################################
# In this section, we set the user authentication, app ID, and the location
# of the image we want as an input. 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 image input you want to add
IMAGE_FILE_LOCATION = 'YOUR_IMAGE_FILE_LOCATION'

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)

with open(IMAGE_FILE_LOCATION, "rb") as f:
    file_bytes = f.read()

post_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        base64=file_bytes\
                    )\
                )\
            )\
        ]
    ),
    metadata=metadata
)

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

<script>
    ////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the location
    // of the image we want as an input. 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 image input you want to add
    const BYTES_STRING = '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAAoACgDASIAAhEBAxEB/8QAGQAAAgMBAAAAAAAAAAAAAAAAAAYDBQcE/8QAMBAAAQMDAwMDAgQHAAAAAAAAAQIDBAAFEQYSIQcTMTJBURRhCBYikSNScXKhsdH/xAAZAQACAwEAAAAAAAAAAAAAAAAFBgIDBAf/xAAtEQABAwMBBgQHAQAAAAAAAAABAgMRAAQhMQUSE0FRYQaBocEUFiJCcrHR8P/aAAwDAQACEQMRAD8A3+RYY1unSYzCS0ttZUkAgktn0q5yT7jPyDUC4wdGwycH5U2Kt9ZQ7VI1qw5PkvQy3CSVPpf7aQjuKyFH25xzn3pHn3TVNy01Hl2hyy6YdkSpKsS9sl/6RlI3rRu3dxWd6spwnAGPIJTfl925fcLaoSDHXvyo6i9SlCQrU9wKln3OyWiaDN1RAbW3kKbSd7gPtwMkH/tTWy9afuy1iPfnXMAblITwkE4yf08cn3pSbYt1uts24XH6fUbiLAuY1MWyGkLEmUW0rcCRvUpQ5CtwKQCPgi4S1ZbDe4sd9NntDEe79m3uOBLTr0IR9jzodSMqUpTu9JJ8owD7UTT4ZCfv9PbP7860m+s+HBSrejWRuz2kAxoesGYxTW/Zlpkwo1vkuSly3UgKWQUhHJUvIHsAaKTemF8XE6sWmxyZkiaZrMh1jv8ArQNpUVqB8FW0njHqx4zRVVhsph1KlKk5xQ+7uHmikaSJrQerMByet2IwvtuTLa4xv2k7Rk84H9x/esHv92d01boenLXGcuiWrFIhLlpbcaQ2/JdK3VJCkAq2pAR7Zz7YxWudY9fxNIdQbNGkR5TyX4aisNNpUMFZAzkj4NK0jq9ZpbLr0PSlzkhrlZDaQlP3P8Q4/ap3F87bPucJEkx/hHv60b2TYXLrKN5sramYECSQRk9M6c6zmJ+eb5Hi22M7cnWGIQgFLbX0zSo4PDa1YBcTgDyMjJ/qbGPabH08SJt1Uzc9QqRliGg5QySPKvgc+TyfYDmmTUWpNYz7ctxoQdPQshCktupckDJUPUcJT6DwMq8YyaQ9VL0pCS8zapcq4SVOBZmPDO8/cnknlWcDBwn4NYnPjLkQ+qE9OtOVlYpeVHDCEkkkJyT+SuQzy5Y0ru6Ez511/Efa5s1fdkOtyVurIxgdlQAA9gOKKPwolU7remU5hCGYEgo38KUv9I/0TRTDYJCWQBSF4rIN/CRgAR0iTpVD1j1g/qDqJcJqlKcjB9bcda142MpOEJAzgeMnjyTSyze5KEuNRpDoDvC0oe4X9iAeaKKFK+oya6fbOqYbDTeEiAPKpHdS3gBLYc7RQkp3ApQog+cq8nwPJrljzxnPZbUfnugn/NFFRgEVch9xKsH0H8pg6e3x3T3UC1ajaZITGkJLoS4MKbOUrzz/ACKVRRRVzVwtoQmhG1NkWu0HuI+JI8u/Kv/Z';

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "base64": BYTES_STRING\
                    },\
                }\
            }\
        ]
    });

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

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the location
// of the image we want as an input. 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 image input you want to add
const IMAGE_FILE_LOCATION = 'YOUR_IMAGE_FILE_LOCATION';

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);

const fs = require("fs");
const imageBytes = fs.readFileSync(IMAGE_FILE_LOCATION);

stub.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },

inputs: [\
            { data: { image: { base64: imageBytes } } }\
        ]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

package com.clarifai.example;

import com.clarifai.channel.ClarifaiChannel;
import com.clarifai.credentials.ClarifaiCallCredentials;
import com.clarifai.grpc.api.*;
import com.clarifai.grpc.api.status.*;
import com.google.protobuf.ByteString;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

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 image input you want to add
    static final String IMAGE_FILE_LOCATION = "YOUR_IMAGE_FILE_LOCATION";

public static void main(String[] args) throws IOException {

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

MultiInputResponse postInputsResponse = stub.postInputs(
            PostInputsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .addInputs(
                Input.newBuilder().setData(
                    Data.newBuilder().setImage(
                        Image.newBuilder()
                        .setBase64(ByteString.copyFrom(Files.readAllBytes(
                            new File(IMAGE_FILE_LOCATION).toPath()
                        )))
                    )
                )
            ).build()
        );

if (postInputsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            throw new RuntimeException("Post inputs failed, status: " + postInputsResponse.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 this to whatever image input you want to add
$IMAGE_FILE_LOCATION = 'YOUR_IMAGE_FILE_LOCATION';

$client = ClarifaiClient::grpc();

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

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

$imageData = file_get_contents($IMAGE_FILE_LOCATION); // Get the image bytes data from the location

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [\
      {\
        "data": {\
          "image": {\
            "base64": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAAoACgDASIAAhEBAxEB/8QAGQAAAgMBAAAAAAAAAAAAAAAAAAYDBQcE/8QAMBAAAQMDAwMDAgQHAAAAAAAAAQIDBAAFEQYSIQcTMTJBURRhCBYikSNScXKhsdH/xAAZAQACAwEAAAAAAAAAAAAAAAAFBgIDBAf/xAAtEQABAwMBBgQHAQAAAAAAAAABAgMRAAQhMQUSE0FRYQaBocEUFiJCcrHR8P/aAAwDAQACEQMRAD8A3+RYY1unSYzCS0ttZUkAgktn0q5yT7jPyDUC4wdGwycH5U2Kt9ZQ7VI1qw5PkvQy3CSVPpf7aQjuKyFH25xzn3pHn3TVNy01Hl2hyy6YdkSpKsS9sl/6RlI3rRu3dxWd6spwnAGPIJTfl925fcLaoSDHXvyo6i9SlCQrU9wKln3OyWiaDN1RAbW3kKbSd7gPtwMkH/tTWy9afuy1iPfnXMAblITwkE4yf08cn3pSbYt1uts24XH6fUbiLAuY1MWyGkLEmUW0rcCRvUpQ5CtwKQCPgi4S1ZbDe4sd9NntDEe79m3uOBLTr0IR9jzodSMqUpTu9JJ8owD7UTT4ZCfv9PbP7860m+s+HBSrejWRuz2kAxoesGYxTW/Zlpkwo1vkuSly3UgKWQUhHJUvIHsAaKTemF8XE6sWmxyZkiaZrMh1jv8ArQNpUVqB8FW0njHqx4zRVVhsph1KlKk5xQ+7uHmikaSJrQerMByet2IwvtuTLa4xv2k7Rk84H9x/esHv92d01boenLXGcuiWrFIhLlpbcaQ2/JdK3VJCkAq2pAR7Zz7YxWudY9fxNIdQbNGkR5TyX4aisNNpUMFZAzkj4NK0jq9ZpbLr0PSlzkhrlZDaQlP3P8Q4/ap3F87bPucJEkx/hHv60b2TYXLrKN5sramYECSQRk9M6c6zmJ+eb5Hi22M7cnWGIQgFLbX0zSo4PDa1YBcTgDyMjJ/qbGPabH08SJt1Uzc9QqRliGg5QySPKvgc+TyfYDmmTUWpNYz7ctxoQdPQshCktupckDJUPUcJT6DwMq8YyaQ9VL0pCS8zapcq4SVOBZmPDO8/cnknlWcDBwn4NYnPjLkQ+qE9OtOVlYpeVHDCEkkkJyT+SuQzy5Y0ru6Ez511/Efa5s1fdkOtyVurIxgdlQAA9gOKKPwolU7remU5hCGYEgo38KUv9I/0TRTDYJCWQBSF4rIN/CRgAR0iTpVD1j1g/qDqJcJqlKcjB9bcda142MpOEJAzgeMnjyTSyze5KEuNRpDoDvC0oe4X9iAeaKKFK+oya6fbOqYbDTeEiAPKpHdS3gBLYc7RQkp3ApQog+cq8nwPJrljzxnPZbUfnugn/NFFRgEVch9xKsH0H8pg6e3x3T3UC1ajaZITGkJLoS4MKbOUrzz/ACKVRRRVzVwtoQmhG1NkWu0HuI+JI8u/Kv/Z",\
            "allow_duplicate_url": true\
          }\
        }\
      }\
    ]
  }'

Upload Multiple Inputs With IDs ​

In cases where you have your own id and you only have one item per image, you are encouraged to send inputs with your own id. This will help you later match the input to your own database.

If you do not send an id, one will be created for you. If you have more than one item per image, it is recommended that you put the product id in the metadata.

##################################################################################
# In this section, we set the user authentication, app ID, and the URLs and IDs
# of the images we want as inputs. 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 whatever inputs you want to add
IMAGE_URL_1 = 'https://samples.clarifai.com/metro-north.jpg'
IMAGE_URL_2 = 'https://samples.clarifai.com/puppy.jpeg'
INPUT_ID_1 = 'mytrain'
INPUT_ID_2 = 'mypuppy'

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_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                id=INPUT_ID_1,\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL_1,\
                        allow_duplicate_url=True\
                    )\
                )\
            ),\
            resources_pb2.Input(\
                id=INPUT_ID_2,\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL_2,\
                        allow_duplicate_url=True\
                    )\
                )\
            ),\
        ]
    ),
    metadata=metadata
)

if post_inputs_response.status.code != status_code_pb2.SUCCESS:
    print("There was an error with your request!")
    for input_object in post_inputs_response.inputs:
        print("Input " + input_object.id + " status:")
        print(input_object.status)
    raise Exception("Post inputs failed, status: " + post_inputs_response.status.description)

<!--index.html file-->

<script>
    ////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the URLs and IDs
    // of the images we want as inputs. 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 whatever inputs you want to add
    const IMAGE_URL_1 = 'https://samples.clarifai.com/metro-north.jpg';
    const IMAGE_URL_2 = 'https://samples.clarifai.com/puppy.jpeg';
    const INPUT_ID_1 = 'input1';
    const INPUT_ID_2 = 'puppy1';

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL_1,\
                        "allow_duplicate_url": true\
                    }\
                },\
                "id": INPUT_ID_1\
            },\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL_2,\
                        "allow_duplicate_url": true\
                    }\
                },\
                "id": INPUT_ID_2\
            }\
        ]
    });

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

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the URLs and IDs
// of the images we want as inputs. 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 whatever inputs you want to add
const IMAGE_URL_1 = 'https://samples.clarifai.com/metro-north.jpg';
const IMAGE_URL_2 = 'https://samples.clarifai.com/puppy.jpeg';
const INPUT_ID_1 = 'train1';
const INPUT_ID_2 = 'puppy1';

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.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },

inputs: [\
            {\
                id: INPUT_ID_1,\
                data: {image: {url: IMAGE_URL_1, allow_duplicate_url: true}}\
            },\
            {\
                id: INPUT_ID_2,\
                data: {image: {url: IMAGE_URL_2, allow_duplicate_url: true}}\
            },\
        ]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            for (const input of response.inputs) {
                console.log("Input " + input.id + " status: ");
                console.log(JSON.stringify(input.status, null, 2) + "\n");
            }

throw new Error("Post inputs failed, status: " + response.status.description);
        }
    }
);

package com.clarifai.example;

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

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 whatever inputs you want to add
    static final String IMAGE_URL_1 = "https://samples.clarifai.com/metro-north.jpg";
    static final String IMAGE_URL_2 = "https://samples.clarifai.com/puppy.jpeg";
    static final String INPUT_ID_1 = "train1";
    static final String INPUT_ID_2 = "puppy1";

public static void main(String[] args) {

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

MultiInputResponse postInputsResponse = stub.postInputs(
            PostInputsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .addInputs(
                Input.newBuilder()
                .setId(INPUT_ID_1)
                .setData(
                    Data.newBuilder().setImage(
                        Image.newBuilder()
                        .setUrl(IMAGE_URL_1)
                        .setAllowDuplicateUrl(true)
                    )
                )
            )
            .addInputs(
                Input.newBuilder()
                .setId(INPUT_ID_2)
                .setData(
                    Data.newBuilder().setImage(
                        Image.newBuilder()
                        .setUrl(IMAGE_URL_2)
                        .setAllowDuplicateUrl(true)
                    )
                )
            )
            .build()
        );

if (postInputsResponse.getStatus().getCode() != StatusCode.SUCCESS) {
            for (Input input: postInputsResponse.getInputsList()) {
                System.out.println("Input " + input.getId() + " status: ");
                System.out.println(input.getStatus() + "\n");
            }

throw new RuntimeException("Post inputs failed, status: " + postInputsResponse.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 whatever inputs you want to add
$IMAGE_URL_1 = "https://samples.clarifai.com/metro-north.jpg";
$IMAGE_URL_2 = "https://samples.clarifai.com/puppy.jpeg";
$INPUT_ID_1 = "train1";
$INPUT_ID_2 = "puppy1";

$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->PostInputs(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new PostInputsRequest([\
            "user_app_id" => $userDataObject,\
            "inputs" => [\
                new Input([\
                    // The Input object wraps the Data object in order to meet the API specification\
                    "id" => $INPUT_ID_1,\
                    "data" => new Data([\
                        // The Data object is constructed around the Image object. It offers a container that has additional image independent\
                        // metadata. In this particular use case, no other metadata is needed to be specified\
                        "image" => new Image([\
                            // In the Clarifai platform, an image is defined by a special Image object\
                            "url" => $IMAGE_URL_1,\
                            "allow_duplicate_url" => true\
                        ])\
                    ])\
                ]),\
                new Input([\
                    "id" => $INPUT_ID_2,\
                    "data" => new Data([\
                        "image" => new Image([\
                            "url" => $IMAGE_URL_2,\
                            "allow_duplicate_url" => true\
                        ])\
                    ])\
                ])\
            ]\
        ]),
        $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) {
    print "There was an error with your request!" . "<br>";
    foreach ($response->getInputs() as $input_object) {
        print "Input " . $input_object->getId() . " status: ";
        print $input_object->getStatus()->getDetails() . "<br>";
    }
    throw new Exception("Post inputs failed, status: " . $response->getStatus()->getDescription());
}

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [\
      {\
        "data": {\
          "image": {\
            "url": "https://samples.clarifai.com/metro-north.jpg",\
            "allow_duplicate_url": true\
          }\
        },\
        "id": "train1"\
      },\
      {\
        "data": {\
          "image": {\
            "url": "https://samples.clarifai.com/puppy.jpeg",\
            "allow_duplicate_url": true\
          }\
        },\
        "id": "puppy1"\
      }\
    ]
  }'

Upload Inputs With Concepts ​

You can add inputs with concepts via URLs or bytes. Concepts play an important role in creating your own models. Concepts also help you search for inputs.

When you add a concept to an input, you need to indicate whether the concept is present in it or not.

##################################################################################
# In this section, we set the user authentication, app ID, and the input to add
# with concept. 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 whatever input and concept you want to add
IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg'
CONCEPT_ID = 'charlie'

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_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL,\
                        allow_duplicate_url=True\
                    ),\
                    concepts=[resources_pb2.Concept(id=CONCEPT_ID, value=1.)]\
                )\
            )\
        ]
    ),
    metadata=metadata
)

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

<script>
    ////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the input to add
    // with concept. 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 whatever input and concept you want to add
    const IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg';
    const CONCEPT_ID = 'charlie';

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL,\
                        "allow_duplicate_url": true\
                    },\
                    // Optionally add a concept with your input\
                    "concepts": [\
                        {\
                            "id": CONCEPT_ID,\
                            "value": 1\
                        }\
                    ]\
                }\
            }\
        ]
    });

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

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the input to add
// with concept. 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.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        inputs: [{\
            data: {\
                image: { url: IMAGE_URL, allow_duplicate_url: true },\
                concepts: [{ id: CONCEPT_ID, value: 1. }]\
            }\
        }]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

if (response.status.code !== 10000) {
            throw new Error("Post inputs 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 whatever input and concept you want to add
    static final String IMAGE_URL = "https://samples.clarifai.com/puppy.jpeg";
    static final String CONCEPT_ID = "charlie";

public static void main(String[] args) {

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

MultiInputResponse postInputsResponse = stub.postInputs(
            PostInputsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .addInputs(
                Input.newBuilder().setData(
                    Data.newBuilder()
                    .setImage(
                        Image.newBuilder()
                        .setUrl(IMAGE_URL)
                        .setAllowDuplicateUrl(true)
                    )
                    .addConcepts(
                        Concept.newBuilder()
                        .setId(CONCEPT_ID)
                        .setValue(1f)
                    )
                )
            ).build()
        );

}
}

<?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 whatever input and concept you want to add
$IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg';
$CONCEPT_ID = 'charlie';

use Clarifai\Api\Concept;
use Clarifai\ClarifaiClient;
use Clarifai\Api\Data;
use Clarifai\Api\Image;
use Clarifai\Api\Input;
use Clarifai\Api\PostInputsRequest;
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->PostInputs(
        // The request object carries the request along with the request status and other metadata related to the request itself
        new PostInputsRequest([\
            "user_app_id" => $userDataObject,\
            "inputs" => [\
                new Input([\
                    // The Input object wraps the Data object in order to meet the API specification\
                    "data" => new Data([\
                        // The Data object is constructed around the Image object. It offers a container that has additional image independent\
                        // metadata. In this particular use case, no other metadata is needed to be specified\
                        "image" => new Image([\
                            // In the Clarifai platform, an image is defined by a special Image object\
                            "url" => $IMAGE_URL,\
                            "allow_duplicate_url" => true\
                        ]),\
                        "concepts" => [\
                            new Concept([\
                            "id" => $CONCEPT_ID,\
                            "value" => 1\
                        ])\
                        ]\
                    ])\
                ])\
            ]\
        ]),
        $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) {
    print $response->getStatus()->getDetails();
    throw new Exception("Failure response: " . $response->getStatus()->getDescription());
}

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [\
      {\
        "data": {\
          "image": {\
            "url": "https://samples.clarifai.com/puppy.jpeg",\
            "allow_duplicate_url": true\
          },\
          "concepts":[\
            {\
              "id": "charlie",\
              "value": 1\
            }\
          ]\
        }\
      }\
    ]
  }'

Upload Inputs With Multiple Concepts ​

You can also add an input with multiple concepts in a single API call. You can provide the concepts in a list and iterate through it.

You can add the inputs via URLs or bytes.

##################################################################################
# In this section, we set the user authentication, app ID, and the input to add
# with concepts. 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 whatever input and concepts you want to add
IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg'
CONCEPT_IDS_LIST = ['one', 'two', 'three', 'four', 'five', 'six']

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_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL,\
                        allow_duplicate_url=True\
                    ),\
                    # We use Python list comprehension to iterate through the list of concepts\
                    concepts=[resources_pb2.Concept(id=str(i), value=1.) for i in CONCEPT_IDS_LIST]\
                )\
            )\
        ]
    ),
    metadata=metadata
)

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

<script>
    ////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the input to add
    // with concepts. 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 whatever input and concepts you want to add
    const IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg';
    const CONCEPT_IDS_LIST = ['one', 'two', 'three', 'four', 'five', 'six'];

// We use a map function to iterate through the list of concepts
    const myFunction = () => {
       return CONCEPT_IDS_LIST.map((concept)=>({"id":concept,"value":1}));
    }

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL,\
                        "allow_duplicate_url": true\
                    },\
\
                    "concepts": myFunction()\
                }\
            }\
        ]
    });

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

</script>

//index.js file

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

// We use a map function to iterate through the list of concepts
const myFunction = () => {
    return CONCEPT_IDS_LIST.map((concept) => ({"id":concept,"value":1}));
 }

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.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        inputs: [{\
            data: {\
                image: { url: IMAGE_URL, allow_duplicate_url: true },\
                concepts: myFunction()\
            }\
        }]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }
        if (response.status.code !== 10000) {
            throw new Error("Post inputs failed, status: " + response.status.description);
        }
    }
);

Upload Inputs With Custom Metadata ​

In addition to adding an input with concepts, you can also add an input with custom metadata. This metadata will then be searchable. Metadata can be any arbitrary JSON.

If you have more than one item per image, it is recommended to put the id in the metadata like:

{
  "product_id": "xyz"
}

####################################################################################
# In this section, we set the user authentication, app ID, and the custom metadata
# and input we want to add. 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 whatever input and custom metadata you want to add
CUSTOM_METADATA = {"id": "id001", "type": "animal", "size": 100}
IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg'

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)

input_metadata = Struct()

input_metadata.update(CUSTOM_METADATA)

post_inputs_response = stub.PostInputs(
    service_pb2.PostInputsRequest(
        user_app_id=userDataObject,
        inputs=[\
            resources_pb2.Input(\
                data=resources_pb2.Data(\
                    image=resources_pb2.Image(\
                        url=IMAGE_URL,\
                        allow_duplicate_url=True\
                    ),\
                    metadata=input_metadata\
                )\
            )\
        ]
    ),
    metadata=metadata
)

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

<script>
    ///////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the input and custom
    // metadata we want to add. 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 whatever input and custom metadata you want to add
    const IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg';
    const CUSTOM_METADATA = { "id": "id001", "type": "animal", "size": 100 };

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs": [\
            {\
                "data": {\
                    "image": {\
                        "url": IMAGE_URL,\
                        "allow_duplicate_url": true\
                    },\
                    "metadata": CUSTOM_METADATA\
                }\
            }\
        ]
    });

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

</script>

//index.js file

///////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the input and custom
// metadata we want to add. 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 whatever input and custom metadata you want to add
const IMAGE_URL = 'https://samples.clarifai.com/puppy.jpeg';
const CUSTOM_METADATA = { id: "id001", type: "animal", size: 100 };

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.PostInputs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        inputs: [{\
            data: {\
                image: { url: IMAGE_URL, allow_duplicate_url: true },\
                metadata: CUSTOM_METADATA\
            }\
        }]
    },
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

package com.clarifai.example;

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

public class ClarifaiExample {

//////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the input
    // we want to add. 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 this to whatever input you want to add
    static final String IMAGE_URL = "https://samples.clarifai.com/puppy.jpeg";

public static void main(String[] args) {

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

MultiInputResponse postInputsResponse = stub.postInputs(
            PostInputsRequest.newBuilder()
            .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
            .addInputs(
                Input.newBuilder().setData(
                    Data.newBuilder()
                        .setImage(
                            Image.newBuilder()
                                .setUrl(IMAGE_URL)
                                .setAllowDuplicateUrl(true)
                        )
                        .setMetadata(
                            Struct.newBuilder()
                                .putFields("id", Value.newBuilder().setStringValue("id001").build())
                                .putFields("type", Value.newBuilder().setStringValue("animal").build())
                                .putFields("size", Value.newBuilder().setNumberValue(100).build())
                        )
                )
            ).build()
        );

}
}

<?php

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

////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the input and custom
// metadata we want to add. 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 whatever input and custom metadata you want to add
$IMAGE_URL = "https://samples.clarifai.com/puppy.jpeg";
$CUSTOM_METADATA = '{"id": "id001", "type": "animal", "size": 100}';
// Decode a JSON object into a PHP object
$CUSTOM_METADATA_DECODE = var_dump(json_decode($CUSTOM_METADATA));

$client = ClarifaiClient::grpc();

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

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

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [\
      {\
        "data": {\
          "image": {\
            "url": "https://samples.clarifai.com/puppy.jpeg",\
            "allow_duplicate_url": true\
          },\
          "metadata": {"id": "id001", "type": "animal", "size": 100}\
        }\
      }\
    ]
  }'

Upload Inputs From Cloud Storage ​

You can add inputs from various cloud storage platforms, such as S3 (Amazon Simple Storage Service) and GCP (Google Cloud Platform), by simply providing their corresponding URLs. In cases where access credentials are necessary, you can include them as part of the request.

This simplifies the process of adding inputs to our platform, offering a more efficient alternative to the conventional method of using the PostInputs endpoint for users who already have data stored in the cloud platforms.

note

This functionality has been introduced starting from the 10.1 release.

info

Upload Inputs via Cloud Storage URLs ​

Below is an example of pulling inputs from a subfolder of an S3 bucket.

######################################################################################################
# In this section, we set the user authentication, app ID, ID to collect statistics about inputs job
# to be created, and cloud storage URL. Change these strings to run your own example.
######################################################################################################

USER_ID = "YOUR_USER_ID_HERE"
# Your PAT (Personal Access Token) can be found in the Portal under Account > Security
PAT = "YOUR_PAT_HERE"
APP_ID = "YOUR_APP_ID_HERE"
# Change these to create your own extraction job
INPUTS_JOB_ID = ""  # If empty, ID will be autogenerated; if non-empty, the given ID will be used
CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/"

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_inputs_response = stub.PostInputsDataSources(
    service_pb2.PostInputsDataSourcesRequest(
        user_app_id=userDataObject,
        app_pat=PAT,
        data_sources=[\
            resources_pb2.InputsDataSource(\
                inputs_add_job_id=INPUTS_JOB_ID,\
                url=resources_pb2.DataSourceURL(\
                    url=CLOUD_STORAGE_URL,\
                    # Uncomment to add credentials\
                    # credentials=resources_pb2.DataSourceCredentials(\
                    # s3_creds=resources_pb2.AWSCreds(\
                    # id="ADD_ACCESS_ID_HERE",\
                    # secret="ADD_SECRET_HERE",\
                    # region="ADD_AWS_REGION_HERE"\
                    # )\
                    # If using GCP\
                    # gcpCreds="" # GCP uses service account key data (creds.json) as Byte array for authentication\
                    # ),\
                ),\
            )\
        ],
    ),
    metadata=metadata,
)

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

print(post_inputs_response)

<!--index.html file-->

<script>
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, ID to collect statistics about inputs job
    // to be created, and cloud storage URL. 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 create your own extraction job
    const INPUTS_JOB_ID = "";  // If empty, ID will be autogenerated; if non-empty, the given ID will be used
    const CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/";

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "app_pat": PAT,
        "data_sources": [\
            {\
                "inputs_add_job_id": INPUTS_JOB_ID,\
                "url": {\
                    "url": CLOUD_STORAGE_URL,\
                    // Uncomment to add credentials\
                   /* "credentials": {\
                        "s3_creds": { "id": "ADD_ACCESS_ID_HERE", "secret": "ADD_SECRET_HERE", "region": "ADD_AWS_REGION_HERE" }\
                    }*/\
                }\
            }\
        ]

});

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

fetch("https://api.clarifai.com/v2/inputs/data_sources/", 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, ID to collect statistics about inputs job
// to be created, and cloud storage URL. 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.PostInputsDataSources(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "app_pat": PAT,
        "data_sources": [\
            {\
                "inputs_add_job_id": INPUTS_JOB_ID,\
                "url": {\
                    "url": CLOUD_STORAGE_URL,\
                    // Uncomment to add credentials\
                    /* "credentials": {\
                         "s3_creds": { "id": "ADD_ACCESS_ID_HERE", "secret": "ADD_SECRET_HERE", "region": "ADD_AWS_REGION_HERE" }\
                     }*/\
                }\
            }\
        ]

},
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

console.log(response);
    }

);

package com.clarifai.example;

public class ClarifaiExample {

///////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, ID to collect statistics about inputs job
    // to be created, and cloud storage URL. 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 create your own extraction job
    static final String INPUTS_JOB_ID = "";  // If empty, ID will be autogenerated; if non-empty, the given ID will be used
    static final String CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/";

///////////////////////////////////////////////////////////////////////////////////
    // YOU DO NOT NEED TO CHANGE ANYTHING BELOW THIS LINE TO RUN THIS EXAMPLE
    ///////////////////////////////////////////////////////////////////////////////////
    public static void main(String[] args) {

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

MultiInputsAddJobResponse postInputsResponse = stub.postInputsDataSources(
                PostInputsDataSourcesRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setAppPat(PAT)
                        .addDataSources(InputsDataSource.newBuilder().setInputsAddJobId(INPUTS_JOB_ID)
                                .setUrl(DataSourceURL.newBuilder()
                                        .setUrl(CLOUD_STORAGE_URL)
                                // Uncomment to add credentials
                                /*.setCredentials(DataSourceCredentials.newBuilder()
                                                .setS3Creds(AWSCreds.newBuilder()
                                                        .setId("ADD_ACCESS_ID_HERE")
                                                        .setSecret("ADD_SECRET_HERE")
                                                        .setRegion("ADD_AWS_REGION_HERE")
                                                )
                                        )*/
                                )
                        ).build()
        );

System.out.println(postInputsResponse);

}

}

<?php

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

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, ID to collect statistics about inputs job
// to be created, and cloud storage URL. 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 create your own extraction job
$INPUTS_JOB_ID = ''; # If empty, ID will be autogenerated; if non-empty, the given ID will be used
$CLOUD_STORAGE_URL = 's3://samples.clarifai.com/storage/';

use Clarifai\ClarifaiClient;
use Clarifai\Api\PostInputsDataSourcesRequest;
use Clarifai\Api\InputsDataSource;
use Clarifai\Api\DataSourceURL;
use Clarifai\Api\DataSourceCredentials;
use Clarifai\Api\AWSCreds;
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->PostInputsDataSources(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new PostInputsDataSourcesRequest([\
        'user_app_id' => $userDataObject,\
        'app_pat' => $PAT,\
        'data_sources' => [\
            new InputsDataSource([\
                'inputs_add_job_id' => $INPUTS_JOB_ID,\
                'url' => new DataSourceURL([\
                    'url' => $CLOUD_STORAGE_URL,\
                    // Uncomment to add credentials\
                    /*'credentials' => new DataSourceCredentials([\
                        's3_creds' => new AWSCreds([\
                            'id' => 'ADD_ACCESS_ID_HERE',\
                            'secret' => 'ADD_SECRET_HERE',\
                            'region' => 'ADD_AWS_REGION_HERE'\
                        ])\
                    ])*/\
                ])\
            ])\
        ]\
    ]),
    $metadata
)->wait();

echo $response->serializeToJsonString();

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs/data_sources/" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "app_pat": "YOUR_PAT_HERE",
    "data_sources": [\
        {\
            "inputs_add_job_id": "",\
            "url": {\
                "url": "s3://samples.clarifai.com/storage/",\
                "credentials": {\
                    "s3_creds": {"id":"ADD_ACCESS_ID_HERE", "secret":"ADD_SECRET_HERE", "region":"ADD_AWS_REGION_HERE"},\
                    // Or, you can use GCP credentials\
                    "gcpCreds": "" // GCP uses service account key data (creds.json) as Byte array for authentication\
                }\
            }\
        }\
    ]
  }'

Output Example

status {
  code: SUCCESS
  description: "Ok"
  req_id: "8759d87e31403bbd838794fe6016f36d"
}
inputs_add_jobs {
  id: "2581ebd8d7cd42e7ac0da2bec14d5426"
  progress {
  }
  created_at {
    seconds: 1708361354
    nanos: 820114719
  }
  modified_at {
    seconds: 1708361354
    nanos: 847655746
  }
  extraction_jobs {
    status {
      code: JOB_QUEUED
      description: "Job is queued to be ran."
    }
    id: "2a6f1f69cced42029986a72009e7d4da"
    url: "s3://samples.clarifai.com/storage/"
    progress {
    }
    created_at {
      seconds: 1708361354
      nanos: 835105396
    }
    modified_at {
      seconds: 1708361354
      nanos: 835105396
    }
  }
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
}

Track Upload Process ​

After starting to pull the inputs from a cloud storage service, you can track the progress of the exercise. Note that we’ll use the inputs_extraction_job_id returned after running the extraction job.

###################################################################################################
# In this section, we set the user authentication, app ID, and the inputs extraction job 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 Portal under Account > Security
PAT = "YOUR_PAT_HERE"
APP_ID = "YOUR_APP_ID_HERE"
# Change this ID to whatever inputs you want to track their upload process
INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da"

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_inputs_extraction_response = stub.GetInputsExtractionJob(
    service_pb2.GetInputsExtractionJobRequest(
        user_app_id=userDataObject,
        inputs_extraction_job_id=INPUTS_EXTRACTION_JOB_ID
    ),
    metadata=metadata,
)

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

print(get_inputs_extraction_response)

<!--index.html file-->

<script>
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the inputs extraction job 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 ID to whatever inputs you want to track their upload process
    const INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da";

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

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/inputs/jobs/extraction/${INPUTS_EXTRACTION_JOB_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 inputs extraction job 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.GetInputsExtractionJob(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "inputs_extraction_job_id": INPUTS_EXTRACTION_JOB_ID

},
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

console.log(response);
    }

);

package com.clarifai.example;

public class ClarifaiExample {

///////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the inputs extraction job 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";
    // Change this ID to whatever inputs you want to track their upload process
    static final String INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da";

public static void main(String[] args) {

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

SingleInputsExtractionJobResponse getInputsResponse = stub.getInputsExtractionJob(
                GetInputsExtractionJobRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setInputsExtractionJobId(INPUTS_EXTRACTION_JOB_ID)
                        .build()
        );

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

System.out.println(getInputsResponse);

}

}

<?php

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

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the inputs extraction job 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 ID to whatever inputs you want to track their upload process
$INPUTS_EXTRACTION_JOB_ID = '2a6f1f69cced42029986a72009e7d4da';

use Clarifai\ClarifaiClient;
use Clarifai\Api\GetInputsExtractionJobRequest;
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->GetInputsExtractionJob(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new GetInputsExtractionJobRequest([\
        'user_app_id' => $userDataObject,\
        'inputs_extraction_job_id' => $INPUTS_EXTRACTION_JOB_ID\
\
    ]),
    $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());
}

echo $response->serializeToJsonString();

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs/jobs/extraction/YOUR_INPUTS_EXTRACTION_JOB_ID_HERE" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \

Output Example

status {
  code: SUCCESS
  description: "Ok"
  req_id: "bae1f832c8931d47388f875653e7035d"
}
inputs_extraction_job {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "2a6f1f69cced42029986a72009e7d4da"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708361354
    nanos: 835105000
  }
  modified_at {
    seconds: 1708361355
    nanos: 386004000
  }
}

List Inputs Extraction Jobs ​

You can list all your inputs extraction jobs and get their details.

##################################################################
# 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 Portal under Account > Security
PAT = "YOUR_PAT_HERE"
APP_ID = "YOUR_APP_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_inputs_extraction_jobs = stub.ListInputsExtractionJobs(
    service_pb2.ListInputsExtractionJobsRequest(
        user_app_id=userDataObject, per_page=1000, page=1
    ),
    metadata=metadata,
)

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

print(list_inputs_extraction_jobs)

<!--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";

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

fetch(`https://api.clarifai.com/v2/users/${USER_ID}/apps/${APP_ID}/inputs/jobs/extraction?per_page=1000&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.
//////////////////////////////////////////////////////////////////////

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.ListInputsExtractionJobs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        per_page: 1000,
        page: 1

},
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

console.log(response);
    }

);

package com.clarifai.example;

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));

MultiInputsExtractionJobResponse listInputsResponse = stub.listInputsExtractionJobs(
                ListInputsExtractionJobsRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setPerPage(100).setPage(1)
                        .build()
        );

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

System.out.println(listInputsResponse);

}

}

<?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';

use Clarifai\ClarifaiClient;
use Clarifai\Api\ListInputsExtractionJobsRequest;
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->ListInputsExtractionJobs(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new ListInputsExtractionJobsRequest([\
        'user_app_id' => $userDataObject,\
        'per_page'=> 1000,\
        'page'=> 1\
\
    ]),
    $metadata
)->wait();

echo $response->serializeToJsonString();

?>

curl -X GET "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs/jobs/extraction?per_page=1000&page=1" \
  -H "Authorization: Key YOUR_PAT_HERE" \
  -H "Content-Type: application/json" \

Output Example

----
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "487d863784804390a92e1108ee1ae1fb"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708406450
    nanos: 685101000
  }
  modified_at {
    seconds: 1708406451
    nanos: 191007000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "16d65cdff5d64ae8ba94ae59f5d7f43c"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708406156
    nanos: 2926000
  }
  modified_at {
    seconds: 1708406156
    nanos: 560108000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "423b4dfa36f64fffbe79cf845918d4c0"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708405684
    nanos: 297689000
  }
  modified_at {
    seconds: 1708405684
    nanos: 778885000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "a5af6a185ab148d4b7eb02e713d3340d"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708405639
    nanos: 186106000
  }
  modified_at {
    seconds: 1708405639
    nanos: 696943000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "1c10da09706d40448bf11fc5aaa8664b"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708405297
    nanos: 953730000
  }
  modified_at {
    seconds: 1708405298
    nanos: 506209000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "10ad7ba72e5e49899a042637178c9452"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708404787
    nanos: 575667000
  }
  modified_at {
    seconds: 1708404788
    nanos: 141744000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "8d7a240f39494ce18c3a5f4aeea687c1"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708403207
    nanos: 89134000
  }
  modified_at {
    seconds: 1708403207
    nanos: 729276000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "2a6f1f69cced42029986a72009e7d4da"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708361354
    nanos: 835105000
  }
  modified_at {
    seconds: 1708361355
    nanos: 386004000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "6db64516daf04abd97852407f9076e42"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708361312
    nanos: 309789000
  }
  modified_at {
    seconds: 1708361313
    nanos: 435552000
  }
}
inputs_extraction_jobs {
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
  id: "7e4bd42e84294e8f9423e0a01783e3b1"
  url: "s3://samples.clarifai.com/storage/"
  progress {
    image_inputs_count: 3
    video_inputs_count: 1
  }
  created_at {
    seconds: 1708354769
    nanos: 17131000
  }
  modified_at {
    seconds: 1708354769
    nanos: 473323000
  }
  input_template {
    data {
      concepts {
        id: "lamborghini23_A"
        value: 1
      }
      concepts {
        id: "spiderman_a"
        value: 1
      }
      metadata {
        fields {
          key: "id"
          value {
            string_value: "id001"
          }
        }
      }
    }
    dataset_ids: "dataset-1"
  }
}
-----

Cancel Extraction Jobs ​

You can cancel the process of extraction of inputs from a cloud storage service. Note that we’ll use the inputs_extraction_job_id returned after starting the extraction process.

#####################################################################################################
# In this section, we set the user authentication, app ID, and the inputs extraction job 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 Portal under Account > Security
PAT = "YOUR_PAT_HERE"
APP_ID = "YOUR_APP_ID_HERE"
# Change this ID to whatever inputs you want to cancel their upload process
INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da"

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)

cancel_inputs_extraction_response = stub.CancelInputsExtractionJobs(
    service_pb2.CancelInputsExtractionJobsRequest(
        user_app_id=userDataObject, ids=[INPUTS_EXTRACTION_JOB_ID]
    ),
    metadata=metadata,
)

if cancel_inputs_extraction_response.status.code != status_code_pb2.SUCCESS:
    print(cancel_inputs_extraction_response.status)
    raise Exception(
        "Cancel input failed, status: "
        + cancel_inputs_extraction_response.status.description
    )

print(cancel_inputs_extraction_response)

<!--index.html file-->

<script>
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the inputs extraction job 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 ID to whatever inputs you want to cancel their upload process
    const INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da";

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

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the inputs extraction job 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.CancelInputsExtractionJobs(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        ids: [INPUTS_EXTRACTION_JOB_ID]

},
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

console.log(response);
    }

);

package com.clarifai.example;

public class ClarifaiExample {

//////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the inputs extraction job 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";
    // Change this ID to whatever inputs you want to cancel their upload process
    static final String INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da";

public static void main(String[] args) {

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

MultiInputsExtractionJobResponse cancelInputsResponse = stub.cancelInputsExtractionJobs(
                CancelInputsExtractionJobsRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .addIds(INPUTS_EXTRACTION_JOB_ID)
                        .build()
        );

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

System.out.println(cancelInputsResponse);

}

}

<?php

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

///////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the inputs extraction job 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 ID to whatever inputs you want to cancel their upload process
$INPUTS_EXTRACTION_JOB_ID = "2a6f1f69cced42029986a72009e7d4da";

use Clarifai\ClarifaiClient;
use Clarifai\Api\CancelInputsExtractionJobsRequest;
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->CancelInputsExtractionJobs(
    // The request object carries the request along with the request status and other metadata related to the request itself
    new CancelInputsExtractionJobsRequest([\
        'user_app_id' => $userDataObject,\
        'ids' => [$INPUTS_EXTRACTION_JOB_ID]\
    ]),
    $metadata
)->wait();

echo $response->serializeToJsonString();

?>

Upload Inputs With Concepts and Datasets ​

You can also add inputs from cloud storage platforms while attaching relevant concepts, assigning them to an already existing dataset, or adding other metadata information to them.

The input_template parameter allows you to do that.

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

USER_ID = "YOUR_USER_ID_HERE"
# Your PAT (Personal Access Token) can be found in the Portal under Account > Security
PAT = "YOUR_PAT_HERE"
APP_ID = "YOUR_APP_ID_HERE"
# Change these to make your own extraction
INPUTS_JOB_ID = ""
CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/"
CUSTOM_METADATA = {"id": "id001"}
DATASET_ID_1 = "dataset-1"
CONCEPT_ID_1 = "lamborghini23_A"
CONCEPT_ID_2 = "spiderman_a"

##############################################################################
# YOU DO NOT NEED TO CHANGE ANYTHING BELOW THIS LINE TO RUN THIS 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)

input_metadata = Struct()

input_metadata.update(CUSTOM_METADATA)

post_inputs_response = stub.PostInputsDataSources(
    service_pb2.PostInputsDataSourcesRequest(
        user_app_id=userDataObject,
        app_pat=PAT,
        data_sources=[\
            resources_pb2.InputsDataSource(\
                inputs_add_job_id=INPUTS_JOB_ID,\
                url=resources_pb2.DataSourceURL(url=CLOUD_STORAGE_URL),\
                input_template=resources_pb2.Input(\
                    dataset_ids=[DATASET_ID_1],  # List of dataset IDs that this input is part of\
                    data=resources_pb2.Data(\
                        metadata=input_metadata,\
                        concepts=[\
                            resources_pb2.Concept(id=CONCEPT_ID_1, value=1),\
                            resources_pb2.Concept(id=CONCEPT_ID_2, value=1),\
                        ],\
                    ),\
                ),\
            )\
        ],
    ),
    metadata=metadata,
)

print(post_inputs_response)

<!--index.html file-->

<script>
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the details of the extraction job.
    // 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 make your own extraction
    const INPUTS_JOB_ID = "";
    const CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/";
    const CUSTOM_METADATA = { "id": "id001" };
    const DATASET_ID_1 = "dataset-1";
    const CONCEPT_ID_1 = "lamborghini23_A";
    const CONCEPT_ID_2 = "spiderman_a";

const raw = JSON.stringify({
        "user_app_id": {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "app_pat": PAT,
        "data_sources": [\
            {\
                "inputs_add_job_id": INPUTS_JOB_ID,\
                "url": {\
                    "url": CLOUD_STORAGE_URL,\
\
                },\
                "input_template": {\
                    "dataset_ids": [DATASET_ID_1],\
                    "data": {\
                        "metadata": CUSTOM_METADATA,\
                        "concepts": [\
                            {\
                                "id": CONCEPT_ID_1,\
                                "value": 1\
                            },\
                            {\
                                "id": CONCEPT_ID_2,\
                                "value": 1\
                            }\
                        ]\
                    }\
                }\
            }\
        ]

});

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

</script>

//index.js file

////////////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the details of the extraction job.
// 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.PostInputsDataSources(
    {
        user_app_id: {
            "user_id": USER_ID,
            "app_id": APP_ID
        },
        "app_pat": PAT,
        "data_sources": [\
            {\
                "inputs_add_job_id": INPUTS_JOB_ID,\
                "url": {\
                    "url": CLOUD_STORAGE_URL\
                },\
                "input_template": {\
                    "dataset_ids": [DATASET_ID_1],\
                    "data": {\
                        "metadata": CUSTOM_METADATA,\
                        "concepts": [\
                            {\
                                "id": CONCEPT_ID_1,\
                                "value": 1\
                            },\
                            {\
                                "id": CONCEPT_ID_2,\
                                "value": 1\
                            }\
                        ]\
                    }\
                }\
            }\
        ]

},
    metadata,
    (err, response) => {
        if (err) {
            throw new Error(err);
        }

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

console.log(response);
    }

);

package com.clarifai.example;

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

public class ClarifaiExample {

///////////////////////////////////////////////////////////////////////////////////////////////////////////
    // In this section, we set the user authentication, app ID, and the details of the extraction job.
    // 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 make your own extraction
    static final String INPUTS_JOB_ID = "";
    static final String CLOUD_STORAGE_URL = "s3://samples.clarifai.com/storage/";
    static final String CUSTOM_METADATA_1 = "id";
    static final String CUSTOM_METADATA_2 = "id001";
    static final String DATASET_ID_1 = "dataset-1";
    static final String CONCEPT_ID_1 = "lamborghini23_A";
    static final String CONCEPT_ID_2 = "spiderman_a";

public static void main(String[] args) {

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

MultiInputsAddJobResponse postInputsResponse = stub.postInputsDataSources(
                PostInputsDataSourcesRequest.newBuilder()
                        .setUserAppId(UserAppIDSet.newBuilder().setUserId(USER_ID).setAppId(APP_ID))
                        .setAppPat(PAT)
                        .addDataSources(InputsDataSource.newBuilder().setInputsAddJobId(INPUTS_JOB_ID)
                                .setUrl(DataSourceURL.newBuilder()
                                        .setUrl(CLOUD_STORAGE_URL)
                                )
                                .setInputTemplate(Input.newBuilder()
                                        .addDatasetIds(DATASET_ID_1)
                                        .setData(Data.newBuilder()
                                                .setMetadata(
                                                        Struct.newBuilder()
                                                                .putFields(CUSTOM_METADATA_1, Value.newBuilder().setStringValue(CUSTOM_METADATA_2).build())
                                                )
                                                .addConcepts(Concept.newBuilder()
                                                        .setId(CONCEPT_ID_1)
                                                        .setValue(1f)
                                                )
                                                .addConcepts(Concept.newBuilder()
                                                        .setId(CONCEPT_ID_2)
                                                        .setValue(1f)
                                                )
                                        ))
                        ).build()
        );

System.out.println(postInputsResponse);

}

}

<?php

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

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// In this section, we set the user authentication, app ID, and the details of the extraction job.
// 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 make your own extraction
$INPUTS_JOB_ID = '';
$CLOUD_STORAGE_URL = 's3://samples.clarifai.com/storage/';
$CUSTOM_METADATA = '{"id": "id001"}';
$DATASET_ID_1 = 'dataset-1';
$CONCEPT_ID_1 = 'lamborghini23_A';
$CONCEPT_ID_2 = 'spiderman_a';

use Clarifai\ClarifaiClient;
use Clarifai\Api\PostInputsDataSourcesRequest;
use Clarifai\Api\InputsDataSource;
use Clarifai\Api\DataSourceURL;
use Clarifai\Api\Concept;
use Clarifai\Api\Data;
use Clarifai\Api\Input;
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\
]);

// Decode the JSON object into a PHP object
$CUSTOM_METADATA_DECODE = var_dump(json_decode($CUSTOM_METADATA));

echo $response->serializeToJsonString();

?>

curl -X POST "https://api.clarifai.com/v2/users/YOUR_USER_ID_HERE/apps/YOUR_APP_ID_HERE/inputs/data_sources/" \
-H "Authorization: Key YOUR_PAT_HERE" \
-H "Content-Type: application/json" \
-d '{
"app_pat": "YOUR_PAT_HERE",
    "data_sources": [\
        {\
            "inputs_add_job_id": "",\
            "url": {\
                "url": "s3://samples.clarifai.com/storage/"\
            },\
            "input_template": {\
                "dataset_ids": ["dataset-1"],\
                "data": {\
                    "metadata": { "id": "id001" },\
                    "concepts": [\
                        {\
                            "id": "lamborghini23_A",\
                            "value": 1\
                        },\
                        {\
                            "id": "spiderman_a",\
                            "value": 1\
                        }\
                    ]\
                }\
            }\
        }\
    ]
  }'

Output Example

status {
  code: SUCCESS
  description: "Ok"
  req_id: "32694c6a3ef8fe3f6704502c0b053734"
}
inputs_add_jobs {
  id: "66b5ca001e754111a81c4839cdabed10"
  progress {
  }
  created_at {
    seconds: 1708500170
    nanos: 508992497
  }
  modified_at {
    seconds: 1708500170
    nanos: 582792601
  }
  extraction_jobs {
    status {
      code: JOB_QUEUED
      description: "Job is queued to be ran."
    }
    id: "7e9b139f65fb4426a3d273d609758d34"
    url: "s3://samples.clarifai.com/storage/"
    progress {
    }
    created_at {
      seconds: 1708500170
      nanos: 550291872
    }
    modified_at {
      seconds: 1708500170
      nanos: 550291872
    }
    input_template {
      data {
        concepts {
          id: "lamborghini23_A"
          value: 1
        }
        concepts {
          id: "spiderman_a"
          value: 1
        }
        metadata {
          fields {
            key: "id"
            value {
              string_value: "id001"
            }
          }
        }
      }
      dataset_ids: "dataset-1"
    }
  }
  status {
    code: JOB_COMPLETED
    description: "Job successfully ran."
  }
}

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

Get started for free