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

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

## परिचय

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

## HTTP API

REST API प्रति-छवि operations प्रदान करती है, जिनमें images और annotations अपलोड करना, image details प्राप्त करना, images हटाना, और image tags तथा metadata को प्रबंधित करना शामिल है.

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

किसी local file या URL से एक image अपलोड करने के लिए REST API का उपयोग करें.

जब आप पास करते हैं `image=`तो Roboflow अपने स्वयं के servers से URL प्राप्त करता है। यदि यह URL प्राप्त नहीं कर सकता (गलत URL, private address, या host 4xx status के साथ उत्तर देता है), तो response 400 होता है और संदेश "Could not fetch image URL" से शुरू होता है। यदि host 5xx status के साथ उत्तर देता है या connection विफल हो जाता है, तो response 502 होता है और `retryable: true`होता है, इसलिए आप वही request बाद में फिर से भेज सकते हैं.

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

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

API द्वारा स्वीकार किए गए querystring parameters:

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

```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 के माध्यम से होस्ट की गई image अपलोड करना (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 के लिए 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 tools का उपयोग करें" चुनते हैं.

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

{% tab title="जावास्क्रिप्ट" %}

#### Node.js

हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) और [form-data](https://github.com/form-data/form-data) इस उदाहरण में POST request करने के लिए, इसलिए पहले चलाएँ `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-encoded image के साथ अपलोड करना (अनुशंसित नहीं):**

```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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना**

```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`एक browser-based JavaScript library, जिसमें अन्य बातों के अलावा, आपकी secret API Key को वेब पर उजागर किए बिना सुरक्षित client-side uploads शामिल हैं। यदि आप early access चाहते हैं, तो कृपया [हमसे संपर्क करें](https://roboflow.com/contact).
{% endtab %}

{% tab title="Swift" %}

#### Swift

iOS पर विकास के लिए Swift का उपयोग करते हुए एक उदाहरण upload snippet.

```swift
//एक छवि को प्रदान किए गए project में अपलोड करें
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
        // प्रतिक्रिया को String में पार्स करें
        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="एंड्रॉइड और जावा" %}

#### कोटलिन

#### **base64-encoded image के साथ अपलोड करना:**

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

    // Base 64 एन्कोड करें
    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 Key
    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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```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" // Image URL बदलें
    val API_KEY = "" // आपका API Key
    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()
```

#### एंड्रॉइड (जावा)

#### **base64-encoded image के साथ अपलोड करना:**

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

        // Base 64 एन्कोड करें
        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 Key
        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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```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"; // Image URL बदलें
        String API_KEY = ""; // आपका API Key
        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="रूबी" %}

#### **रूबी**

{% 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)

BUNDLED WITH
   2.2.15
```

{% endcode %}

#### **base64-encoded image के साथ अपलोड करना:**

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

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

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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

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

dataset_name = "your-dataset" # डेटासेट नाम सेट करें (डेटासेट URL में पाया जाता है)
api_key = "" # आपका API KEY यहाँ
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-encoded image के साथ अपलोड करना:**

```php
<?php

// छवि को Base 64 में एन्कोड करें
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // API कुंजी सेट करें
$dataset_name = "your-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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```php
<?php

$api_key = ""; // API कुंजी सेट करें
$dataset_name = "your-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-encoded image के साथ अपलोड करना:**

```go
package main

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

func main() {
	api_key := ""  // आपकी API कुंजी
	dataset_name := "Your-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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```go
package main

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

)

func main() {
	api_key := ""  // आपकी API कुंजी
	dataset_name := "Your-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-encoded image के साथ अपलोड करना:**

```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"; // डेटासेट नाम सेट करें (डेटासेट 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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```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"; // डेटासेट नाम सेट करें (डेटासेट 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 के माध्यम से अपलोड की गई छवियाँ यहाँ मिल सकती हैं `एनोटेट` टैब में, इसके नीचे `असाइन नहीं किया गया` कॉलम में और इस रूप में चिह्नित `API के माध्यम से अपलोड किया गया`.

यदि आप कोई `batch` अपलोड पैरामीटर निर्दिष्ट करते हैं, तो आपकी छवि फिर भी `एनोटेट` टैब में मिलेगी, लेकिन `API के माध्यम से अपलोड किया गया` बैच में जाने के बजाय, यह आपके द्वारा निर्दिष्ट बैच में मिलेगी।

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

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

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

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

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

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

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

#### उदाहरण

एक [VOC XML एनोटेशन](https://roboflow.com/formats/pascal-voc-xml) को ID वाली एक छवि से `abc123` में `your-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` नामक डेटासेट में `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')
# एनोटेशन फ़ाइल और लेबल मैप [0=flower, 1=leaf] के साथ एक JSON स्ट्रिंग बनाएँ
json_payload="{ \"annotationFile\": \"$txt_content\", \"labelmap\":{\"0\":\"flower\", \"1\":\"leaf\"} }"

# एनोटेशन + 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="जावास्क्रिप्ट" %}
हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) इस उदाहरण में POST request करने के लिए, इसलिए पहले चलाएँ `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" %}

#### कोटलिन

#### **base64-encoded image के साथ अपलोड करना:**

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

    // Base 64 एन्कोड करें
    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 Key
    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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```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" // Image URL बदलें
    val API_KEY = "" // आपका API Key
    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()
```

#### एंड्रॉइड (जावा)

#### **base64-encoded image के साथ अपलोड करना:**

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

        // Base 64 एन्कोड करें
        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 Key
        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 के माध्यम से कहीं और होस्ट की गई Image जोड़ना:**

```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"; // Image URL बदलें
        String API_KEY = ""; // आपका API Key
        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 ऑब्जेक्ट लौटाता है:

```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
        },
        "embedding": number[]
    }
}
```

### किसी 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"
}'
```

यह एंडपॉइंट POST बॉडी में निम्न मान स्वीकार करता है:

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

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

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

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

दोनों endpoints के लिए एक ऐसी API key आवश्यक है जिसमें `image:tag` स्कोप हो।

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

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

```
- imageId (string) - batch update के लिए body में आवश्यक, single update में path से अनुमानित
- metadata (object) - छवि के user metadata पर सेट करने के लिए key-value pairs.
- 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 को असिंक्रोनस रूप से अपडेट करें। प्रति अनुरोध अधिकतम 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

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

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

`Project.upload()` यह उच्च-स्तरीय "do the right thing" helper है। यह एक छवि और एक वैकल्पिक मेल खाने वाली annotation फ़ाइल स्वीकार करता है और दोनों को एक ही कॉल में प्रोजेक्ट में भेज देता है।

```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 / आदि annotation
    split="train",                    # train | valid | test
    batch_name="ingest-2026-05",     # वैकल्पिक; web UI में uploads को समूहित करता है
    tag_names=["camera-A", "indoor"], # वैकल्पिक; tags लागू करें
    is_prediction=False,              # मॉडल-जनरेटेड annotations के लिए True सेट करें जो समीक्षा की प्रतीक्षा कर रहे हैं
    num_retry_uploads=2,              # अस्थायी upload विफलताओं पर पुनः प्रयास
)
print(result)
```

`single_upload()` यह एक निचले-स्तर का variant है जो समान arguments लेता है और छवि तथा (यदि प्रदान की गई हो) annotation दोनों के लिए रॉ API responses लौटाता है।

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

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

जब annotations अभी मौजूद नहीं होते और छवि सीधे किसी labeler के पास जाती है, तब उपयोगी।

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

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

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

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

`save_annotation()` प्रोजेक्ट में पहले से मौजूद एक छवि पर एक annotation पोस्ट करता है। कहीं और बनाए गए labels जोड़ने, या मॉडल prediction को ground truth में बदलने के लिए उपयोगी।

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

पास करें `annotation_labelmap="./labelmap.yaml"` यदि आपके annotation फ़ॉर्मैट को इसकी आवश्यकता हो, तो class indices को class names में मैप करने के लिए.

के साथ सहेजने से `is_prediction=True` छवि को एक review job में ले जाया जा सकता है। देखें [जहाँ predictions जाती हैं](/datasets/hi/create-and-upload/upload-a-dataset.md#where-predictions-land).

### एक छवि का metadata प्राप्त करें

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

छवि metadata, वर्तमान split, और annotation status लौटाता है।

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

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

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

workspace-स्तर (यह उन छवियों को हटाता है, चाहे उन्हें कोई भी project संदर्भित कर रहा हो - सावधानी से उपयोग करें):

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

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

से `रोबोफ्लो` 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>