> 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 एपीआई

REST API इमेज अपलोड और एनोटेशन, इमेज विवरण प्राप्त करने, इमेज हटाने, और इमेज टैग व मेटाडेटा प्रबंधित करने के लिए प्रति-इमेज ऑपरेशन्स प्रदान करता है।

### एक इमेज अपलोड करें

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

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

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

API द्वारा स्वीकार किए जाने वाले querystring पैरामीटर:

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

```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-encode करें](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). ऐसा करने का सबसे आसान तरीका है उपयोग करना [git for Windows installer](https://git-scm.com/downloads) जिसमें शामिल भी है `curl` और `base64` कमांड-लाइन टूल्स जब आप installation के दौरान "Use Git and optional Unix tools from the Command Prompt" चुनते हैं।

फिर आप ऊपर वाले वही कमांड्स उपयोग कर सकते हैं।
{% 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-encoded इमेज के साथ अपलोड करना (अनुशंसित नहीं):**

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

#### वेब

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

{% tab title="Swift" %}

#### Swift

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

```swift
// दिए गए project में एक image upload करें
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="Android और Java" %}

#### Kotlin

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

```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 में encode करें
    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" // Dataset का नाम सेट करें (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 से connection कॉन्फ़िगर करें
        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 Key
    val DATASET_NAME = "your-dataset" // Dataset का नाम सेट करें (Dataset URL में मिलता है)

    // Upload 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 से connection कॉन्फ़िगर करें
        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-encoded इमेज के साथ अपलोड करना:**

```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 में encode करें
        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"; // Dataset का नाम सेट करें (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 से connection कॉन्फ़िगर करें
            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 Key
        String DATASET_NAME = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)

        // Upload 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 से connection कॉन्फ़िगर करें
            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)

प्लैटफ़ॉर्म
  x64-mingw32
  x86_64-linux

निर्भरताएँ
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

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

{% endcode %}

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

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

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

dataset_name = "your-dataset" # Dataset का नाम सेट करें (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 इमेज के साथ अपलोड करना:**

```php
<?php

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

```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 इमेज के साथ अपलोड करना:**

```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 को बाइट स्लाइस में पढ़ें.
    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" // डेटासेट का नाम सेट करें (डेटासेट 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 इमेज के साथ अपलोड करना:**

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

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

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

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

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

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

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

{% 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 के रूप में भेजने के बजाय annotation फ़ाइल की सामग्री को 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 स्ट्रिंग बनाएं
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="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-encoded इमेज के साथ अपलोड करना:**

```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 में encode करें
    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" // Dataset का नाम सेट करें (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 से connection कॉन्फ़िगर करें
        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 Key
    val DATASET_NAME = "your-dataset" // Dataset का नाम सेट करें (Dataset URL में मिलता है)

    // Upload 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 से connection कॉन्फ़िगर करें
        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-encoded इमेज के साथ अपलोड करना:**

```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 में encode करें
        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"; // Dataset का नाम सेट करें (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 से connection कॉन्फ़िगर करें
            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 Key
        String DATASET_NAME = "your-dataset"; // Dataset का नाम सेट करें (Dataset URL में मिलता है)

        // Upload 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 से connection कॉन्फ़िगर करें
            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
        },
        "embedding": number[]
    }
}
```

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

आप 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 स्थिति लौटाता है.
{% 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 body में निम्न मान स्वीकार करता है:

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

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

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

आप REST API का उपयोग करके अपने workspace में छवियों पर custom metadata और tags लिख सकते हैं. दो endpoint हैं: एक एकल छवि को synchronously अपडेट करने के लिए, और एक batch में अधिकतम 1,000 छवियों को अपडेट करने के लिए.

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

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

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

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

आपको इनमें से कम से कम एक field शामिल करनी होगी. आप एक ही अनुरोध में एक ही metadata key या tag को सेट और हट नहीं सकते.

#### एकल छवि

एकल छवि के लिए 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 asynchronously अपडेट करें. प्रति अनुरोध अधिकतम 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"
}
```

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

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

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

## Python SDK

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

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

`Project.upload()` उच्च-स्तरीय "सही काम करने वाला" सहायक है. यह एक single image के साथ एक वैकल्पिक matching annotation file स्वीकार करता है और दोनों को एक ही call में 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",   # वैकल्पिक; matched 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,              # model-generated annotations के लिए True सेट करें जो समीक्षा की प्रतीक्षा कर रहे हैं
    num_retry_uploads=2,              # अस्थायी upload विफलताओं पर पुनः प्रयास
)
print(result)
```

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

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

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

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

### अपलोड करने से पहले एक छवि को validate करें

`check_valid_image()` API को hit किए बिना Roboflow की local size / format checks चलाता है:

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

### मौजूदा छवि में एक annotation जोड़ें

`save_annotation()` एक ऐसी छवि पर annotation पोस्ट करता है जो पहले से project में है. कहीं और बनाए गए labels जोड़ने, या model prediction को ground truth में promote करने के लिए उपयोगी.

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

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

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

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

छवि metadata, वर्तमान split, और annotation स्थिति लौटाता है.

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

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

```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+ में uploads पर एक नोट

के अनुसार `roboflow` 1.3.6, SDK Pillow के माध्यम से पुनः-एन्कोड करने के बजाय मूल image bytes अपलोड करता है. यह web uploader के साथ समानता बहाल करता है और Roboflow server को SHA-256 द्वारा uploads को deduplicate करने देता है. यदि आपके पास ऐसा automation है जो एक ही image को दो बार अपलोड करता है (जैसे उसे कई batches में जोड़ने के लिए), तो आपको दूसरा upload बिना अतिरिक्त storage credits खर्च किए सफल होता दिखेगा.

## CLI

एक image और उसकी वैकल्पिक annotation, tags, या metadata को अपलोड करने के लिए 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>एक annotation file का path</td></tr><tr><td><code>-m</code>, <code>--labelmap</code></td><td>एक label map file का path</td></tr><tr><td><code>-s</code>, <code>--split</code></td><td>डेटासेट split: <code>train</code>, <code>valid</code>, या <code>test</code>. डिफ़ॉल्ट है <code>train</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).