> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/datasets/hi/manage/manage-images.md).

# इमेजें प्रबंधित करें

REST API और Python SDK के माध्यम से अलग-अलग इमेजें अपलोड, एनोटेट, निरीक्षण, टैग और हटाएँ।

## के बारे में

Roboflow आपको REST API और Python SDK के माध्यम से किसी प्रोजेक्ट में अलग-अलग छवियाँ अपलोड, एनोटेट, निरीक्षण, टैग और हटाने की सुविधा देता है। जब आपको बल्क डेटासेट अपलोड फ्लो से अधिक सूक्ष्म नियंत्रण चाहिए, तब इन ऑपरेशनों का उपयोग करें - उदाहरण के लिए, एक-एक करके किसी स्ट्रीम से एक छवि अपलोड करना, बाद में एनोटेशन जोड़ना, या छवि मेटाडेटा और टैग अपडेट करना। किसी पूरी लेबल की गई डेटासेट को एक साथ बल्क में इम्पोर्ट करने के लिए, देखें [डेटासेट अपलोड करें](/datasets/hi/create-and-upload/upload-a-dataset.md).

## HTTP एपीआई

REST API छवि अपलोड करने, एनोटेशन प्राप्त करने, छवि विवरण लाने, छवियाँ हटाने, और छवि टैग तथा मेटाडेटा प्रबंधित करने के लिए प्रति-छवि ऑपरेशन उपलब्ध कराता है।

### एक छवि अपलोड करें

स्थानीय फ़ाइल या URL से एक छवि अपलोड करने के लिए REST API का उपयोग करें।

जब आप पास करते हैं `image=`, Roboflow URL को अपने सर्वरों से प्राप्त करता है। यदि वह URL प्राप्त नहीं कर सकता (खराब URL, निजी पता, या होस्ट 4xx स्थिति के साथ जवाब देता है), तो प्रतिक्रिया 400 होगी और संदेश "Could not fetch image URL" से शुरू होगा। यदि होस्ट 5xx स्थिति के साथ जवाब देता है या कनेक्शन विफल होता है, तो प्रतिक्रिया 502 होगी जिसमें `retryable: true`, ताकि आप वही अनुरोध बाद में फिर से भेज सकें।

{% tabs %}
{% tab title="cURL" %}

#### पैरामीटर

API द्वारा स्वीकार किए गए querystring पैरामीटर:

**api\_key**: <https://app.roboflow.com/account/api> से प्राप्त करें\
**image**: \[वैकल्पिक] जोड़ने के लिए छवि का URL। यदि आपकी छवि कहीं और होस्ट की गई है, तो इसका उपयोग करें (जब आप अनुरोध बॉडी में base64-एन्कोडेड छवि POST नहीं करते हैं, तब आवश्यक)।\
**name**: \[वैकल्पिक] छवि का फ़ाइलनाम (यदि सेट नहीं है, तो हम इसे अनुमान लगाने की कोशिश करेंगे)।\
**batch**: \[वैकल्पिक] इस नाम के साथ छवियों को एक बैच के अंतर्गत समूहित करें\
**tag**: \[वैकल्पिक] कई बार निर्दिष्ट किया जा सकता है। अपलोड की गई छवि में टैग जोड़ें।\
**split**: \[वैकल्पिक] इनमें से एक: train, valid, या test (डिफ़ॉल्ट train)।\
**sequence\_number**: \[वैकल्पिक] यदि आप डेटासेट में अपनी छवियों का क्रम बनाए रखना चाहते हैं, तो आप अपलोड की गई छवियों को बढ़ते हुए sequence numbers दे सकते हैं।\
**sequence\_size**: \[वैकल्पिक] अनुक्रम में छवियों की कुल संख्या। यदि सेट नहीं है, तो डिफ़ॉल्ट 100,000 है।\
**inference\_id**: \[वैकल्पिक] roboflow inference detection से लौटाया गया inference ID। यह inference\_id छवि को Model Monitoring (enterprise feature) में roboflow detection के साथ संबद्ध करने की अनुमति देता है।

#### Linux या macOS

नामक एक स्थानीय फ़ाइल अपलोड करना `YOUR_IMAGE.jpg` multipart/form-data का उपयोग करके (अनुशंसित):

```
curl -F name=YOUR_IMAGE.jpg -F split=train \
-F file=@YOUR_IMAGE.jpg \
"https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload?\
api_key=$ROBOFLOW_API_KEY"
```

वैकल्पिक रूप से, base64-एन्कोडेड छवि अपलोड करना:

```bash
base64 -i YOUR_IMAGE.jpg | curl -d @- \
"https://api.roboflow.com/dataset/your-dataset/upload?\
api_key=$ROBOFLOW_API_KEY&\
name=YOUR_IMAGE.jpg&\
split=train&\
batch=BATCH_NAME_FOR_UPLOAD"
```

URL के माध्यम से वेब पर होस्ट की गई छवि अपलोड करना (इसे [URL एन्कोड करना](https://www.urlencoder.org/)):

```bash
curl -X POST "https://api.roboflow.com/dataset/your-dataset/upload?\
api_key=$ROBOFLOW_API_KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png&\
name=201-956-1246.png&\
split=train"
```

#### Windows

आपको इंस्टॉल करना होगा [Windows के लिए curl](https://curl.se/windows/) और [Windows के लिए GNU का base64 टूल](http://gnuwin32.sourceforge.net/packages/coreutils.htm). ऐसा करने का सबसे आसान तरीका [Windows के लिए git इंस्टॉलर](https://git-scm.com/downloads) जिसमें यह भी शामिल है `curl` और `base64` कमांड-लाइन टूल्स, जब आप इंस्टॉलेशन के दौरान "कमांड प्रॉम्प्ट से Git और वैकल्पिक Unix टूल्स का उपयोग करें" चुनते हैं।

तब आप ऊपर दिए गए वही कमांड उपयोग कर सकते हैं।
{% endtab %}

{% tab title="JavaScript" %}

#### Node.js

हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) और [form-data](https://github.com/form-data/form-data) इस उदाहरण में POST अनुरोध करने के लिए, इसलिए पहले चलाएँ `npm install axios form-data` निर्भरता इंस्टॉल करने के लिए।

#### **multipart/form-data के साथ अपलोड करना (अनुशंसित):**

```javascript
const axios = require("axios");
const fs = require("fs");
const FormData = require('form-data');

const formData = new FormData();
formData.append("name", "YOUR_IMAGE.jpg");
formData.append("file", fs.createReadStream("YOUR_IMAGE.jpg"));
formData.append("split", "train");

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY"
    },
    data: formData,
    headers: formData.getHeaders()
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

#### **base64-एन्कोडेड छवि के साथ अपलोड करना (अनुशंसित नहीं):**

```javascript
const axios = require("axios");
const fs = require("fs");

const image = fs.readFileSync("YOUR_IMAGE.jpg", {
    encoding: "base64"
});

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY",
        name: "YOUR_IMAGE.jpg",
        split: "train",
        batch: "YOUR_BATCH_NAME"
    },
    data: image,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना**

```javascript
const axios = require("axios");

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY",
        image: "https://i.imgur.com/PEEvqPN.png",
        name: "201-956-1246.png",
        split: "train"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

#### वेब

हम वर्तमान में बीटा परीक्षण कर रहे हैं `roboflow.js`, एक ब्राउज़र-आधारित JavaScript लाइब्रेरी, जिसमें, अन्य बातों के साथ, वेब को आपका गुप्त API Key उजागर किए बिना सुरक्षित क्लाइंट-साइड अपलोड शामिल हैं। यदि आप जल्दी पहुँच चाहते हैं, तो कृपया [हमसे संपर्क करें](https://roboflow.com/contact).
{% endtab %}

{% tab title="Swift" %}

#### Swift

iOS के विकास के लिए Swift का उपयोग करके एक उदाहरण अपलोड स्निपेट।

```swift
//किसी दिए गए प्रोजेक्ट में एक छवि अपलोड करें
public func uploadImage(image: UIImage, project: String, completion: @escaping (UploadResult)->()) {
    let encodedImage = convertImageToBase64String(img: image)
    let uuid = UUID().uuidString
    
    var request = URLRequest(url: URL(string: "https://api.roboflow.com/dataset/\(project)/upload?api_key=\(apiKey!)&name=\(uuid)&split=train")!,timeoutInterval: Double.infinity)

    request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
    request.httpMethod = "POST"
    request.httpBody = encodedImage.toData()
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        // प्रतिक्रिया को स्ट्रिंग में पार्स करें
        guard let data = data else {
            completion(UploadResult.Error)
            return
        }

        do {
            let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
            let duplicate = dict!["duplicate"] as? Bool
            
            if duplicate ==  true {
                completion(UploadResult.Duplicate)
            } else {
                let success = dict!["success"] as! Bool
                if success == true {
                    completion(UploadResult.Success)
                } else {
                    completion(UploadResult.Error)
                }
            }

        } catch {
            print(error.localizedDescription)
            completion(UploadResult.Error)
        }
    }.resume()
}

func convertImageToBase64String (img: UIImage) -> String {
    return img.jpegData(compressionQuality: 1)?.base64EncodedString() ?? ""
}
```

}
{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="Android और Java" %}

#### Kotlin

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```kotlin
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*

fun main() {
    // छवि का पथ प्राप्त करें
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base64 में एन्कोड करें
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // आपकी API कुंजी
    val DATASET_NAME = "your-dataset" // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

    // URL बनाएँ
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // HTTP अनुरोध
    var connection: HttpURLConnection? = null
    try {
        // URL से कनेक्शन कॉन्फ़िगर करें
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // अनुरोध भेजें
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // प्रतिक्रिया प्राप्त करें
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```kotlin
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder
import java.nio.charset.StandardCharsets

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // छवि URL बदलें
    val API_KEY = "" // आपकी API कुंजी
    val DATASET_NAME = "your-dataset" // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

    // अपलोड URL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
            + URLEncoder.encode(imageURL, "utf-8"))

    // HTTP अनुरोध
    var connection: HttpURLConnection? = null
    try {
        // URL से कनेक्शन कॉन्फ़िगर करें
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // अनुरोध भेजें
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // प्रतिक्रिया प्राप्त करें
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()
```

#### Android (Java)

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```java
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class UploadLocal {
    public static void main(String[] args) throws IOException {
        // छवि का पथ प्राप्त करें
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base64 में एन्कोड करें
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // आपकी API कुंजी
        String DATASET_NAME = "your-dataset"; // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

        // URL बनाएँ
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // HTTP अनुरोध
        HttpURLConnection connection = null;
        try {
            // URL से कनेक्शन कॉन्फ़िगर करें
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type",
                    "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length",
                    Integer.toString(encodedFile.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // अनुरोध भेजें
            DataOutputStream wr = new DataOutputStream(
                    connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // प्रतिक्रिया प्राप्त करें
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // छवि URL बदलें
        String API_KEY = ""; // आपकी API कुंजी
        String DATASET_NAME = "your-dataset"; // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

        // अपलोड URL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // HTTP अनुरोध
        HttpURLConnection connection = null;
        try {
            // URL से कनेक्शन कॉन्फ़िगर करें
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // अनुरोध भेजें
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // प्रतिक्रिया प्राप्त करें
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

{% endtab %}

{% tab title="Ruby" %}

#### **Ruby**

{% code title="Gemfile" %}

```ruby
source "https://rubygems.org"

gem "httparty", "~> 0.18.1"
gem "base64", "~> 0.1.0"
gem "cgi", "~> 0.2.1"
```

{% endcode %}

{% code title="Gemfile.lock" %}

```ruby
GEM
  remote: https://rubygems.org/
  specs:
    base64 (0.1.0)
    cgi (0.2.1)
    httparty (0.18.1)
      mime-types (~> 3.0)
      multi_xml (>= 0.5.2)
    mime-types (3.3.1)
      mime-types-data (~> 3.2015)
    mime-types-data (3.2021.0225)
    multi_xml (0.6.0)

PLATFORMS
  x64-mingw32
  x86_64-linux

DEPENDENCIES
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

साथ बंडल किया गया
   2.2.15
```

{% endcode %}

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```ruby
require 'base64'
require 'httparty'

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
dataset_name = "your-dataset" # Dataset का नाम सेट करें (Dataset URL में मिलता है)
api_key = "" # आपकी API कुंजी यहाँ

params = "?api_key=" + api_key + 
"&name=YOUR_IMAGE.jpg" + 
"&split=train"

response = HTTParty.post(
    "https://api.roboflow.com/dataset/" + dataset_name + "/upload" + params,
    body: encoded, 
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

  puts response

 
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```ruby
require 'httparty'
require 'cgi'

dataset_name = "your-dataset" # Dataset का नाम सेट करें (Dataset URL में मिलता है)
api_key = "" # आपकी API कुंजी यहाँ
img_url = "https://i.imgur.com/PEEvqPN.png" # URL बनाएं

img_url = CGI::escape(img_url)

params = "?api_key=" + api_key + 
"&name=YOUR_IMAGE.jpg" + 
"&split=train" +
"&image=" + img_url

response = HTTParty.post(
    "https://api.roboflow.com/dataset/" + dataset_name + "/upload" + params,
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

puts response
```

{% endtab %}

{% tab title="PHP" %}

#### **PHP**

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```php
<?php

// इमेज को Base64 में एन्कोड करें
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // API कुंजी सेट करें
$dataset_name = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)

// Http अनुरोध के लिए URL
$url = "https://api.roboflow.com/dataset/" 
. $dataset_name .  "/upload" 
.  "?api_key="  .  $api_key  
.  "&name=YOUR_IMAGE.jpg" 
. "&split=train";

// Http अनुरोध सेटअप करें + भेजें
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST',
    'content' => $data
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```php
<?php

$api_key = ""; // API कुंजी सेट करें
$dataset_name = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)
$img_url = "https://i.imgur.com/PEEvqPN.png";

// Http अनुरोध के लिए URL
$url = "https://api.roboflow.com/dataset/" 
. $dataset_name .  "/upload" 
.  "?api_key="  .  $api_key  
.  "&name=YOUR_IMAGE.jpg" 
. "&split=train" 
. "&image=" . urlencode($img_url);

// Http अनुरोध सेटअप करें + भेजें
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST'
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```

{% endtab %}

{% tab title="Go" %}

#### **Go**

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```go
package main

import (
    "bufio"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "os"
	"net/http"
	"strings"
)

func main() {
	api_key := ""  // आपकी API कुंजी
	dataset_name := "Your-Dataset" // Dataset का नाम सेट करें (Dataset URL में मिलता है)

    // डिस्क पर फ़ाइल खोलें।
    f, _ := os.Open("YOUR_IMAGE.jpg")

    // पूरी JPG को byte slice में पढ़ें।
    reader := bufio.NewReader(f)
    content, _ := ioutil.ReadAll(reader)

    // base64 के रूप में एन्कोड करें।
    data := base64.StdEncoding.EncodeToString(content)
	uploadURL := "https://api.roboflow.com/dataset/"+ dataset_name + "/upload"+
    "?api_key=" + api_key +
    "&name=YOUR_IMAGE.jpg" +
    "&split=train"

	res, _ := http.Post(uploadURL, "application/x-www-form-urlencoded", strings.NewReader(data))
    body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(string(body))

}
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```go
package main

import (
    "fmt"
	"net/http"
	"net/url"
	"io/ioutil"

)

func main() {
	api_key := ""  // आपकी API कुंजी
	dataset_name := "Your-Dataset" // Dataset का नाम सेट करें (Dataset URL में मिलता है)
	img_url := "https://i.imgur.com/PEEvqPN.png"


	uploadURL := "https://api.roboflow.com/dataset/"+ dataset_name + "/upload"+
    "?api_key=" + api_key +
    "&name=YOUR_IMAGE.jpg" +
    "&split=train" + "&image=" + url.QueryEscape(img_url)

	res, _ := http.Post(uploadURL, "application/x-www-form-urlencoded", nil)
	body, _ := ioutil.ReadAll(res.Body)
    fmt.Println(string(body))


}
```

{% endtab %}

{% tab title=".NET" %}

#### **.NET**

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```csharp
using System;
using System.IO;
using System.Net;
using System.Text;

namespace UploadLocal
{
    class UploadLocal
    {

        static void Main(string[] args)
        {
            byte[] imageArray = System.IO.File.ReadAllBytes(@"YOUR_IMAGE.jpg");
            string encoded = Convert.ToBase64String(imageArray);
            byte[] data = Encoding.ASCII.GetBytes(encoded);
            string API_KEY = ""; // आपकी API कुंजी
            string DATASET_NAME = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)

            // URL बनाएँ
            string uploadURL =
                    "https://api.roboflow.com/dataset/" +
                            DATASET_NAME + "/upload" +
                            "?api_key=" + API_KEY +
                            "&name=YOUR_IMAGE.jpg" +
                            "&split=train";

            // सेवा अनुरोध कॉन्फ़िगरेशन
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // अनुरोध कॉन्फ़िगर करें
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = data.Length;

            // डेटा लिखें
            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            // प्रतिक्रिया प्राप्त करें
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```csharp
using System;
using System.IO;
using System.Net;
using System.Web;

namespace UploadHosted
{
    class UploadHosted
    {
        static void Main(string[] args)
        {
            string API_KEY = ""; // आपकी API कुंजी
            string DATASET_NAME = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)
            string imageURL = "https://i.imgur.com/PEEvqPN.png";
            imageURL = HttpUtility.UrlEncode(imageURL);

            // URL बनाएँ
            string uploadURL =
                    "https://api.roboflow.com/dataset/" +
                            DATASET_NAME + "/upload" +
                            "?api_key=" + API_KEY +
                            "&name=YOUR_IMAGE.jpg" +
                            "&split=train" +
                            "&image=" + imageURL;

            // सेवा पॉइंट कॉन्फ़िगरेशन
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // Http अनुरोध कॉन्फ़िगर करें
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = 0;

            // प्रतिक्रिया प्राप्त करें
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}
```

{% endtab %}
{% endtabs %}

#### Roboflow में अपलोड की गई छवियाँ देखें

API के माध्यम से अपलोड की गई छवियाँ यहाँ मिल सकती हैं `Annotate` टैब में, `unassigned` कॉलम के अंतर्गत और `uploaded via API`.

के रूप में चिह्नित। `batch` यदि आप एक `Annotate` upload पैरामीटर निर्दिष्ट करते हैं, तो आपकी छवि फिर भी `uploaded via API` बैच में मिलेगी, लेकिन

### एनोटेशन अपलोड करें

यदि आपके पास पहले से मौजूदा एनोटेशन हैं, साथ में आपकी छवियाँ भी हैं, तो आप उन्हें Roboflow पर अपलोड कर सकते हैं।

{% hint style="success" %}
यह इनमें से किसी के साथ काम करता है [हमारे समर्थित एनोटेशन फ़ॉर्मैट्स](http://roboflow.com/formats) जो एक एनोटेशन फ़ाइल का उपयोग करते हैं, जिसमें अपलोड की गई छवि के फ़ाइल नाम का संदर्भ होता है।
{% endhint %}

{% hint style="info" %}
क्या आप जानते हैं? आप API का उपयोग किए बिना, ऐप के Upload पेज पर अपनी छवियों के साथ एनोटेशन फ़ाइलों को ड्रैग और ड्रॉप (या चुन) सकते हैं।
{% endhint %}

जोड़ें `prediction=true` को एनोटेशन को ग्राउंड ट्रुथ के बजाय मॉडल प्रेडिक्शन के रूप में सहेजने के लिए। यदि छवि अभी भी अपलोड बैच में है और अभी तक किसी एनोटेशन जॉब में नहीं है, तो Roboflow उसे उस बैच के लिए Review job में ले जाता है।

जोड़ें `predictionRouting=unassigned` उस मूव को छोड़ने के लिए। एनोटेशन फिर भी सेव होता है और छवि फिर भी एनोटेटेड के रूप में चिह्नित रहती है, लेकिन यह अपने बैच में ही रहती है और unassigned रहती है। उपयोग करें `predictionRouting=review` डिफ़ॉल्ट रूटिंग मांगने के लिए। दोनों मानों के लिए `prediction=true`की आवश्यकता होती है, और आप इन्हें `jobName`.

{% tabs %}
{% tab title="cURL" %}

#### उदाहरण

एक [VOC XML एनोटेशन](https://roboflow.com/formats/pascal-voc-xml) को ID वाली छवि से जोड़ना `abc123` में `your-dataset` dataset कहलाने वाले `YOUR_ANNOTATION.xml`:

```bash
cat YOUR_ANNOTATION.xml | curl -d @- \
"https://api.roboflow.com/dataset/your-dataset/annotate/abc123?\
api_key=YOUR_KEY&\
name=YOUR_ANNOTATION.xml"
```

एक [Darknet TXT एनोटेशन](https://roboflow.com/formats/yolo-darknet-txt) को ID वाली छवि से जोड़ना `abc123` में `your-dataset` dataset कहलाने वाले `YOUR_ANNOTATION.txt` json labelmap का उपयोग करके - इस मामले में हमें केवल body के रूप में भेजने के बजाय एनोटेशन फ़ाइल की सामग्री को json में भेजना होगा।

```bash
#!/bin/bash
# एनोटेशन को json-संगत स्ट्रिंग के रूप में संग्रहीत करें
txt_content=$(cat YOUR_ANNOTATION.txt | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n')
# annotation फ़ाइल और label map [0=flower, 1=leaf] के साथ एक json string बनाएं
json_payload="{ \"annotationFile\": \"$txt_content\", \"labelmap\":{\"0\":\"flower\", \"1\":\"leaf\"} }"

# annotation + labelmap अपलोड करें
echo $json_payload | curl -H "Content-Type: application/json" -d @- \
"https://api.roboflow.com/dataset/cultura-pepino-dark/annotate/abc123?\
api_key=YOUR_KEY&\
name=YOUR_ANNOTATION.txt"
```

{% endtab %}

{% tab title="JavaScript" %}
हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) इस उदाहरण में POST अनुरोध करने के लिए, इसलिए पहले चलाएँ `npm install axios` निर्भरता इंस्टॉल करने के लिए।

**एक स्थानीय छवि अपलोड करना**

```javascript
const axios = require("axios");
const fs = require("fs");

const filename = "YOUR_ANNOTATION.xml";
const annotation = fs.readFileSync(filename, "utf-8");

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/your-dataset/annotate/abc123",
    params: {
        api_key: "YOUR_KEY",
        name: filename
    },
    data: annotation,
    headers: {
        "Content-Type": "text/plain"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

{% endtab %}

{% tab title="Android और Java" %}

#### Kotlin

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```kotlin
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*

fun main() {
    // छवि का पथ प्राप्त करें
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base64 में एन्कोड करें
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // आपकी API कुंजी
    val DATASET_NAME = "your-dataset" // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

    // URL बनाएँ
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // HTTP अनुरोध
    var connection: HttpURLConnection? = null
    try {
        // URL से कनेक्शन कॉन्फ़िगर करें
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // अनुरोध भेजें
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // प्रतिक्रिया प्राप्त करें
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```kotlin
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder
import java.nio.charset.StandardCharsets

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // छवि URL बदलें
    val API_KEY = "" // आपकी API कुंजी
    val DATASET_NAME = "your-dataset" // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

    // अपलोड URL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
            + URLEncoder.encode(imageURL, "utf-8"))

    // HTTP अनुरोध
    var connection: HttpURLConnection? = null
    try {
        // URL से कनेक्शन कॉन्फ़िगर करें
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // अनुरोध भेजें
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // प्रतिक्रिया प्राप्त करें
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()
```

#### Android (Java)

#### **base64-एन्कोडेड छवि के साथ अपलोड करना:**

```java
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class UploadLocal {
    public static void main(String[] args) throws IOException {
        // छवि का पथ प्राप्त करें
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base64 में एन्कोड करें
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // आपकी API कुंजी
        String DATASET_NAME = "your-dataset"; // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

        // URL बनाएँ
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // HTTP अनुरोध
        HttpURLConnection connection = null;
        try {
            // URL से कनेक्शन कॉन्फ़िगर करें
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type",
                    "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length",
                    Integer.toString(encodedFile.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // अनुरोध भेजें
            DataOutputStream wr = new DataOutputStream(
                    connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // प्रतिक्रिया प्राप्त करें
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

**URL के माध्यम से कहीं और होस्ट की गई छवि जोड़ना:**

```java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // छवि URL बदलें
        String API_KEY = ""; // आपकी API कुंजी
        String DATASET_NAME = "your-dataset"; // डेटासेट का नाम सेट करें (डेटासेट URL में मिलता है)

        // अपलोड URL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // HTTP अनुरोध
        HttpURLConnection connection = null;
        try {
            // URL से कनेक्शन कॉन्फ़िगर करें
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // अनुरोध भेजें
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // प्रतिक्रिया प्राप्त करें
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

{% endtab %}
{% endtabs %}

### एक छवि के बारे में विवरण प्राप्त करें

आप REST API का उपयोग करके किसी विशिष्ट छवि का विवरण प्राप्त कर सकते हैं।

किसी विशिष्ट छवि का विवरण प्राप्त करने के लिए, निम्न API endpoint पर GET अनुरोध करें।

```url
https://api.roboflow.com/:workspace/:project/images/:image_id
```

यहाँ छवि के विवरण प्राप्त करने के लिए API अनुरोध का एक उदाहरण है

```bash
curl -X GET "https://api.roboflow.com/my-workspace/my-project-name/images/image-id?api_key=$ROBOFLOW_API_KEY" \
-H 'Content-Type: application/json'
```

यह endpoint एक JSON object लौटाता है जिसमें छवि के बारे में निम्न जानकारी होती है:

```typescript
{
    "image":
        "id": string,
        "name": string,
        "annotation": {
            "key": string,
            "width": number,
            "height": number,
            "boxes": Array<{
                "label": string,
                "x": number,
                "y": number,
                "width": number,
                "height": number
            }>
        },
        "labels": string[],
        "split": string,
        "tags": string[],
        "created": number,
        "urls": {
            "original": string,
            "thumb": string,
            "annotation": string,
            "video": string // केवल वीडियो के लिए
        },
        "mediaType": "image" | "video",
        "segments": object[], // केवल वीडियो के लिए
        "embedding": number[]
    }
}
```

किसी वीडियो के लिए, `urls.original` और `urls.thumb` उसकी पोस्टर छवि को रखता है, `urls.video` एक अल्पकालिक डाउनलोड लिंक है, और `segments` उसके [action segments](/datasets/hi/annotate/annotate/annotate-video-segments.md). `annotation` है `null`, और `format` query parameter 400 error लौटाता है।

### Dataset से एक छवि हटाएँ

आप REST API का उपयोग करके Dataset से छवियाँ हटा सकते हैं।

{% tabs %}
{% tab title="REST API" %}
Dataset से छवियाँ हटाने के लिए, निम्न API endpoint पर DELETE अनुरोध करें, जिसमें endpoint में image IDs पास करें।

```url
https://api.roboflow.com/:workspace/:project/images
```

यहाँ छवियाँ हटाने के लिए API अनुरोध का एक उदाहरण है

```bash
curl "https://api.roboflow.com/my-workspace/my-project/images?api_key=$ROBOFLOW_API_KEY" \
  -X DELETE \
  -H "Content-Type: application/json" \
  -d '{"images": ["1", "2"]}'
```

यदि ऑपरेशन सफल रहा, तो यह endpoint 204 status लौटाता है।
{% endtab %}
{% endtabs %}

### छवि टैग सूचीबद्ध करें, जोड़ें और हटाएँ

आप REST API का उपयोग करके Roboflow पर विशिष्ट छवियों को टैग असाइन कर सकते हैं

{% tabs %}
{% tab title="REST API" %}
Roboflow पर होस्ट की गई छवियों में टैग जोड़ने, हटाने और सेट करने के लिए, निम्न API endpoint पर POST अनुरोध करें। छवि नाम से संबंधित image ID प्राप्त करने के लिए Search API का उपयोग करें:

```url
https://api.roboflow.com/:workspace/:project/images/:image_id/tags
```

यहाँ API अनुरोध का एक उदाहरण है (टैग "add", "remove", या "set" कर सकता है):

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project-name/images/image-id/tags?api_key=$ROBOFLOW_API_KEY" \
-H 'Content-Type: application/json' \
--data \
'{
    "operation": "add",
    "tags": "image_tag_test"
}'
```

यह endpoint POST body में निम्न मान स्वीकार करता है:

```json
{
     // // विकल्प हैं ["add", "remove", "set"]
     "operation": string,
     
     // टैग्स की string arrays
     "tags": string[],
     
}
```

API Roboflow में निर्दिष्ट छवि में टैग जोड़ देगा (याद रखें कि post request में image name नहीं, बल्कि image ID पास करनी है)।
{% endtab %}
{% endtabs %}

### छवि मेटाडेटा और टैग अपडेट करें

आप REST API का उपयोग करके अपने workspace की छवियों में कस्टम मेटाडेटा और टैग लिख सकते हैं। दो endpoints हैं: एक एकल छवि को समकालिक रूप से अपडेट करने के लिए, और एक batch में 1,000 तक छवियों को अपडेट करने के लिए।

दोनों endpoints को `image:tag` scope के साथ एक API key की आवश्यकता होती है।

#### अनुरोध बॉडी

दोनों endpoints समान फ़ील्ड स्वीकार करते हैं (batch endpoint उन्हें एक `updates` array में लपेटता है):

```
- imageId (string) - body में batch update के लिए आवश्यक, single update में path से अनुमानित
- metadata (object) - छवि के user metadata पर सेट करने के लिए key-value जोड़े।
- removeMetadata (string[]) - छवि से हटाने के लिए metadata keys।
- addTags (string[]) - छवि में जोड़ने के लिए tags।
- removeTags (string[]) - छवि से हटाने के लिए tags।
```

आपको इनमें से कम से कम एक फ़ील्ड शामिल करना होगा। आप एक ही अनुरोध में एक ही metadata key या tag को सेट और हटाने दोनों नहीं कर सकते। जो metadata keys शुरू होती हैं `_rf_internal_` वे Roboflow के लिए आरक्षित हैं और अस्वीकृत कर दी जाती हैं।

#### एकल छवि

एकल छवि के लिए metadata और tags अपडेट करें।

```
POST https://api.roboflow.com/:workspace/images/:image/metadata?api_key=YOUR_API_KEY
```

**उदाहरण**

```bash
curl -X POST "https://api.roboflow.com/my-workspace/images/abc123/metadata?api_key=$ROBOFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": { "camera": "front", "blur_score": 0.8 },
    "addTags": ["reviewed"]
  }'
```

**प्रतिक्रिया**

```json
{
    "success": true
}
```

#### बैच अपडेट

एकाधिक छवियों के लिए metadata और tags को asynchronous रूप से अपडेट करें। प्रति अनुरोध 1,000 तक छवियाँ स्वीकार करता है।

```
POST https://api.roboflow.com/:workspace/images/metadata?api_key=YOUR_API_KEY
```

**उदाहरण**

```bash
curl -X POST "https://api.roboflow.com/my-workspace/images/metadata?api_key=$ROBOFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "updates": [
      {
        "imageId": "abc123",
        "metadata": { "camera": "front" },
        "addTags": ["reviewed"]
      },
      {
        "imageId": "def456",
        "removeTags": ["needs-review"]
      }
    ]
  }'
```

**प्रतिक्रिया**

लौटाता है `202` एक task ID के साथ। प्रगति जाँचने के लिए task URL को poll करें।

```json
{
    "taskId": "task-id-here",
    "url": "https://api.roboflow.com/my-workspace/asynctasks/task-id-here"
}
```

देखें [Async Tasks](https://docs.roboflow.com/reference/platform/rest-api/async-tasks) task status को poll करने के तरीके के लिए।

#### त्रुटियाँ

```
- 400 - खाली body, गलत फ़ील्ड प्रकार, या परस्पर विरोधी फ़ील्ड (जैसे metadata और removeMetadata दोनों में एक ही key)।
- 404 - workspace में छवि नहीं मिली (केवल single image endpoint)।
```

## Python SDK

`Project` bulk [`upload_dataset`](/datasets/hi/create-and-upload/upload-a-dataset.md#python-sdk) flow के पूरक per-image operations प्रदान करता है। इनका उपयोग तब करें जब आपको single-image uploads पर अधिक सूक्ष्म नियंत्रण चाहिए, बाद में annotations जोड़ने हों, या stream से एक-एक करके छवियाँ ingest करनी हों।

### एक छवि अपलोड करें (वैकल्पिक annotation के साथ)

`Project.upload()` उच्च-स्तरीय "सब कुछ सही करें" सहायक है। यह एकल छवि के साथ वैकल्पिक matching annotation file स्वीकार करता है और दोनों को एक ही कॉल में project में भेज देता है।

```python
import roboflow

rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace().project("my-detector")

result = project.upload(
    image_path="./photo.jpg",
    annotation_path="./photo.xml",   # वैकल्पिक; मिलान किए गए VOC / COCO / आदि एनोटेशन
    split="train",                    # train | valid | test
    batch_name="ingest-2026-05",     # वैकल्पिक; वेब UI में अपलोड्स को समूहबद्ध करता है
    tag_names=["camera-A", "indoor"], # वैकल्पिक; टैग लागू करें
    is_prediction=False,              # समीक्षा की प्रतीक्षा कर रहे मॉडल-जनित एनोटेशन के लिए True सेट करें
    num_retry_uploads=2,              # क्षणिक अपलोड विफलताओं पर पुनः प्रयास करता है
)
print(result)
```

`single_upload()` एक निम्न-स्तरीय संस्करण है जो समान तर्क लेता है और छवि तथा (यदि प्रदान किया गया हो) एनोटेशन, दोनों के लिए कच्चे API प्रतिक्रियाएँ लौटाता है।

### केवल एक छवि अपलोड करें

```python
project.upload_image(
    image_path="./photo.jpg",
    split="train",
    batch_name="ingest-2026-05",
    tag_names=["camera-A"],
)
```

जब एनोटेशन अभी मौजूद न हों और छवि सीधे किसी लेबलर के पास चली जाए, तब उपयोगी।

### अपलोड करने से पहले किसी छवि को मान्य करें

`check_valid_image()` API को हिट किए बिना Roboflow की स्थानीय आकार / प्रारूप जाँच चलाता है:

```python
if project.check_valid_image("./photo.jpg"):
    project.upload_image("./photo.jpg")
```

### किसी मौजूदा छवि में एक एनोटेशन संलग्न करें

`save_annotation()` प्रोजेक्ट में पहले से मौजूद छवि के विरुद्ध एक एनोटेशन पोस्ट करता है। यह कहीं और बनाए गए लेबल जोड़ने, या मॉडल की भविष्यवाणी को ग्राउंड ट्रुथ में बदलने के लिए उपयोगी है।

```python
project.save_annotation(
    image_id="<image-id>",
    annotation_path="./photo.xml",
    is_prediction=False,
    annotation_overwrite=True,    # किसी भी मौजूदा एनोटेशन को बदलें
)
```

पास करें `annotation_labelmap="./labelmap.yaml"` यदि आपका एनोटेशन प्रारूप इसकी आवश्यकता करे, तो क्लास इंडेक्स को क्लास नामों में मैप करने के लिए।

इसके साथ सहेजने पर `is_prediction=True` छवि को समीक्षा जॉब में ले जा सकता है। देखें [जहाँ भविष्यवाणियाँ पहुँचती हैं](/datasets/hi/create-and-upload/upload-a-dataset.md#where-predictions-land).

### किसी छवि का मेटाडेटा प्राप्त करें

```python
info = project.image("<image-id>")
print(info["name"], info["split"], info["annotations"])
```

छवि मेटाडेटा, वर्तमान स्प्लिट, और एनोटेशन स्थिति लौटाता है।

### छवियाँ हटाएँ

प्रोजेक्ट-स्तर पर (केवल इस प्रोजेक्ट से संबंधित छवियाँ हटाता है):

```python
project.delete_images(["<image-id-1>", "<image-id-2>"])
```

वर्कस्पेस-स्तर पर (यह देखे बिना कि कौन-से प्रोजेक्ट उन्हें संदर्भित करते हैं, छवियाँ हटाता है - सावधानी से उपयोग करें):

```python
workspace.delete_images(["<image-id-1>", "<image-id-2>"])
```

### v1.3.6+ में अपलोड्स पर एक नोट

से `roboflow` 1.3.6 में, SDK Pillow के माध्यम से पुनः-एन्कोड करने के बजाय मूल छवि बाइट्स अपलोड करता है। इससे वेब अपलोडर के साथ समानता बहाल होती है और Roboflow सर्वर SHA-256 द्वारा अपलोड्स को डिडुप्लिकेट कर सकता है। यदि आपके पास ऐसी ऑटोमेशन है जो एक ही छवि को दो बार अपलोड करती है (जैसे, उसे कई बैचों में जोड़ने के लिए), तो आपको दूसरा अपलोड बिना अतिरिक्त स्टोरेज क्रेडिट खर्च किए सफल होता दिखाई देगा।

## CLI

एक छवि और उसके वैकल्पिक एनोटेशन, टैग, या मेटाडेटा को अपलोड करने के लिए CLI का उपयोग करें।

```bash
roboflow image upload photo.jpg -p PROJECT_ID
```

### विकल्प

<table data-search="false"><thead><tr><th>फ्लैग</th><th>विवरण</th></tr></thead><tbody><tr><td><code>-p</code>, <code>--project</code></td><td>प्रोजेक्ट ID (आवश्यक)</td></tr><tr><td><code>-a</code>, <code>--annotation</code></td><td>एनोटेशन फ़ाइल का पथ</td></tr><tr><td><code>-m</code>, <code>--labelmap</code></td><td>लेबल मैप फ़ाइल का पथ</td></tr><tr><td><code>-s</code>, <code>--split</code></td><td>डेटासेट स्प्लिट: <code>प्रशिक्षण</code>, <code>मान्य</code>, या <code>परीक्षण</code>. डिफ़ॉल्ट है <code>प्रशिक्षण</code>.</td></tr><tr><td><code>-t</code>, <code>--tag</code></td><td>अल्पविराम से अलग किए गए टैग नाम</td></tr><tr><td><code>-M</code>, <code>--metadata</code></td><td>मेटाडेटा एक JSON स्ट्रिंग के रूप में</td></tr><tr><td><code>--is-prediction</code></td><td>अपलोड को एक भविष्यवाणी के रूप में चिह्नित करें</td></tr><tr><td><code>-b</code>, <code>--batch</code></td><td>बैच नाम</td></tr></tbody></table>

### उदाहरण

एक एनोटेशन के साथ छवि अपलोड करें:

```bash
roboflow image upload photo.jpg -p my-project -a annotation.xml -s valid
```

टैग और मेटाडेटा के साथ छवि अपलोड करें:

```bash
roboflow image upload photo.jpg -p my-project -t "outdoor,daytime" -M '{"camera_id":"cam001"}'
```

किसी निर्देशिका या `.zip` आर्काइव को अपलोड करने के लिए देखें [डेटासेट अपलोड करें](/datasets/hi/create-and-upload/upload-a-dataset.md).

## MCP सर्वर

अपने AI एजेंट को इससे जोड़ें [MCP सर्वर](https://docs.roboflow.com/agents/mcp-server) और यह इन टूल्स से छवियों को खोज और अपडेट कर सकता है:

<table data-search="false"><thead><tr><th width="290">टूल</th><th>विवरण</th></tr></thead><tbody><tr><td><code>images_search</code></td><td>किसी प्रोजेक्ट के भीतर छवियाँ खोजें।</td></tr><tr><td><code>images_update_metadata</code></td><td>एकल छवि पर मेटाडेटा और टैग अपडेट करें।</td></tr><tr><td><code>images_batch_update_metadata</code></td><td>एकाधिक छवियों पर मेटाडेटा और टैग को बैच में अपडेट करें।</td></tr><tr><td><code>annotations_save</code></td><td>मौजूदा छवि के लिए एक एनोटेशन सहेजें।</td></tr></tbody></table>