> 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/ja/guan-li/manage-images.md).

# 画像を管理

## 概要

Roboflowでは、REST APIとPython SDKを使って、プロジェクト内の個々の画像をアップロード、注釈付け、確認、タグ付け、削除できます。これらの操作は、一括データセットアップロードのフローよりも細かい制御が必要な場合に使用してください。たとえば、ストリームから1枚ずつ画像をアップロードしたり、後から注釈を付けたり、画像のメタデータやタグを更新したりする場合です。ラベル付きデータセット全体を一度にまとめてインポートするには、次を参照してください [データセットをアップロード](/datasets/ja/toappurdo/upload-a-dataset.md).

## HTTP API

REST APIでは、画像と注釈のアップロード、画像詳細の取得、画像の削除、画像タグとメタデータの管理のための、画像単位の操作を提供しています。

### 画像をアップロード

REST APIを使用して、ローカルファイルまたはURLから画像をアップロードします。

次を渡すと `image=`、Roboflowは自社サーバーからURLを取得します。取得できない場合（URLが無効、プライベートアドレス、またはホストが4xxステータスを返す場合）、レスポンスは400で、メッセージは「Could not fetch image URL」で始まります。ホストが5xxステータスを返すか接続に失敗した場合、レスポンスは502で `retryable: true`、そのため後で同じリクエストを再送できます。

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

#### パラメータ

APIが受け付けるクエリ文字列パラメータ：

**api\_key**: <https://app.roboflow.com/account/api> から取得できます\
**image**: \[任意] 追加する画像のURL。画像が別の場所でホストされている場合に使用します（リクエスト本文でbase64エンコードされた画像をPOSTしない場合は必須）。\
**name**: \[任意] 画像のファイル名（設定されていない場合は推測を試みます）。\
**batch**: \[任意] この名前のバッチに画像をまとめます\
**tag**: \[任意] 複数回指定できます。アップロードされた画像にタグを追加します。\
**split**: \[任意] train、valid、testのいずれか（既定はtrain）。\
**sequence\_number**: \[任意] データセット内の画像の順序を保持したい場合、アップロードする画像に増加するシーケンス番号を付けられます。\
**sequence\_size**: \[任意] シーケンス内の画像の総数。未設定の場合、既定は100,000です。\
**inference\_id**: \[任意] roboflowの推論検出から返される推論ID。このinference\_idにより、画像をModel Monitoring（エンタープライズ機能）内のroboflow検出と関連付けられます。

#### Linux または macOS

次のローカルファイルをアップロードします `YOUR_IMAGE.jpg` multipart/form-dataを使用します（推奨）：

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

または、base64エンコードされた画像をアップロードします：

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

URLを介してWeb上でホストされている画像をアップロードします（忘れずに [URLエンコードしてください](https://www.urlencoder.org/)):

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

#### Windows

インストールする必要があります [Windows用curl](https://curl.se/windows/) および [Windows用GNUのbase64ツール](http://gnuwin32.sourceforge.net/packages/coreutils.htm)。最も簡単な方法は [Git for Windowsインストーラー](https://git-scm.com/downloads) を使用することです。これには `curl` および `base64` コマンドラインツールも含まれており、インストール時に「コマンドプロンプトからGitとオプションのUnixツールを使う」を選択します。

その後、上記と同じコマンドを使用できます。
{% endtab %}

{% tab title="JavaScript" %}

#### Node.js

この例では [axios](https://github.com/axios/axios) および [form-data](https://github.com/form-data/form-data) を使ってPOSTリクエストを実行しているため、まず `npm install axios form-data` を実行して依存関係をインストールします。

#### **multipart/form-dataでアップロードする（推奨）：**

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

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

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

#### **base64エンコードされた画像でアップロードする（非推奨）：**

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

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

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

**URLで外部ホストにある画像を追加する**

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

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

#### Web

現在、ベータテストを行っています `roboflow.js`は、ブラウザベースのJavaScriptライブラリで、シークレットAPIキーをWebに公開せずに安全なクライアント側アップロードを行う機能などが含まれています。早期アクセスをご希望の場合は、 [お問い合わせください](https://roboflow.com/contact).
{% endtab %}

{% tab title="Swift" %}

#### Swift

iOS開発向けにSwiftを使ったアップロードのサンプルです。

```swift
// 指定されたプロジェクトに画像をアップロード
public func uploadImage(image: UIImage, project: String, completion: @escaping (UploadResult)->()) {
    let encodedImage = convertImageToBase64String(img: image)
    let uuid = UUID().uuidString
    
    var request = URLRequest(url: URL(string: "https://api.roboflow.com/dataset/\(project)/upload?api_key=\(apiKey!)&name=\(uuid)&split=train")!,timeoutInterval: Double.infinity)

    request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
    request.httpMethod = "POST"
    request.httpBody = encodedImage.toData()
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        // レスポンスを文字列にパース
        guard let data = data else {
            completion(UploadResult.Error)
            return
        }

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

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

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

}
{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="Android & Java" %}

#### Kotlin

#### **base64エンコードされた画像でアップロードする：**

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

fun main() {
    // 画像のパスを取得
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base64でエンコード
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // あなたのAPIキー
    val DATASET_NAME = "your-dataset" // データセット名を設定（データセットURLで確認できます）

    // URLを構築
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエストを送信
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // レスポンスを取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()
```

**URLを介して別の場所でホストされている画像を追加する：**

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

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // 画像URLを置き換えてください
    val API_KEY = "" // あなたのAPIキー
    val DATASET_NAME = "your-dataset" // データセット名を設定（データセットURLで確認できます）

    // アップロードURL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
            + URLEncoder.encode(imageURL, "utf-8"))

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエストを送信
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // レスポンスを取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()
```

#### Android (Java)

#### **base64エンコードされた画像でアップロードする：**

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

public class UploadLocal {
    public static void main(String[] args) throws IOException {
        // 画像のパスを取得
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base64でエンコード
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // あなたのAPIキー
        String DATASET_NAME = "your-dataset"; // データセット名を設定（データセットURLで確認できます）

        // URLを構築
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type",
                    "application/x-www-form-urlencoded");

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

            // リクエストを送信
            DataOutputStream wr = new DataOutputStream(
                    connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // レスポンスを取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

**URLを介して別の場所でホストされている画像を追加する：**

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

public class UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 画像URLを置き換えてください
        String API_KEY = ""; // あなたのAPIキー
        String DATASET_NAME = "your-dataset"; // データセット名を設定（データセットURLで確認できます）

        // アップロードURL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

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

            // リクエストを送信
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // レスポンスを取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

{% endtab %}

{% tab title="Ruby" %}

#### **Ruby**

{% code title="Gemfile" %}

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

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

{% endcode %}

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

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

PLATFORMS
  x64-mingw32
  x86_64-linux

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

BUNDLED WITH
   2.2.15
```

{% endcode %}

#### **base64エンコードされた画像でアップロードする：**

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

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
dataset_name = "your-dataset" # データセット名を設定（データセットURLで確認できます）
api_key = "" # ここにあなたのAPIキー

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

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

  responseを出力

 
```

**URLを介して別の場所でホストされている画像を追加する：**

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

dataset_name = "your-dataset" # データセット名を設定（データセットURLで確認できます）
api_key = "" # ここにあなたのAPIキー
img_url = "https://i.imgur.com/PEEvqPN.png" # URLを構築

img_url = CGI::escape(img_url)

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

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

responseを出力
```

{% endtab %}

{% tab title="PHP" %}

#### **PHP**

#### **base64エンコードされた画像でアップロードする：**

```php
<?php

// 画像をBase64エンコード
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // APIキーを設定
$dataset_name = "your-dataset"; // データセット名を設定（データセット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エンコードされた画像でアップロードする：**

```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エンコードされた画像でアップロードする：**

```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` タブの `unassigned` 列にあり、 `uploaded via API`.

としてマークされています。 `batch` uploadパラメータを指定した場合でも、画像は `Annotate` タブに表示されますが、 `uploaded via API` バッチではなく、指定したバッチに入ります。

### 注釈をアップロードする

既存の注釈が画像とともにある場合、それらをRoboflowにアップロードできます。

{% hint style="success" %}
これは、 [対応している注釈形式のいずれにも](http://roboflow.com/formats) 対応しており、アップロードした画像のファイル名を参照する注釈ファイルを使用します。
{% endhint %}

{% hint style="info" %}
知っていましたか？ APIを使わなくても、アプリのUploadページで画像と一緒に注釈ファイルをドラッグ＆ドロップ（または選択）できます。
{% endhint %}

追加 `prediction=true` を使うと、注釈をground truthではなくモデル予測として保存できます。画像がまだアップロードバッチにあり、まだ注釈ジョブに入っていない場合、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ラベルマップを使っている場合 - この場合は、注釈ファイルの内容を単に本文として送るのではなく、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\"} }"

# 注釈 + ラベルマップをアップロード
echo $json_payload | curl -H "Content-Type: application/json" -d @- \
"https://api.roboflow.com/dataset/cultura-pepino-dark/annotate/abc123?\
api_key=YOUR_KEY&\
name=YOUR_ANNOTATION.txt"
```

{% endtab %}

{% tab title="JavaScript" %}
この例では [axios](https://github.com/axios/axios) を使ってPOSTリクエストを実行しているため、まず `npm install axios` を実行して依存関係をインストールします。

**ローカル画像のアップロード**

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

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

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

{% endtab %}

{% tab title="AndroidとJava" %}

#### Kotlin

#### **base64エンコードされた画像でアップロードする：**

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

fun main() {
    // 画像のパスを取得
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base64でエンコード
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // あなたのAPIキー
    val DATASET_NAME = "your-dataset" // データセット名を設定（データセットURLで確認できます）

    // URLを構築
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエストを送信
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // レスポンスを取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()
```

**URLを介して別の場所でホストされている画像を追加する：**

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

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // 画像URLを置き換えてください
    val API_KEY = "" // あなたのAPIキー
    val DATASET_NAME = "your-dataset" // データセット名を設定（データセットURLで確認できます）

    // アップロードURL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
            + URLEncoder.encode(imageURL, "utf-8"))

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエストを送信
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // レスポンスを取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()
```

#### Android (Java)

#### **base64エンコードされた画像でアップロードする：**

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

public class UploadLocal {
    public static void main(String[] args) throws IOException {
        // 画像のパスを取得
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base64でエンコード
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // あなたのAPIキー
        String DATASET_NAME = "your-dataset"; // データセット名を設定（データセットURLで確認できます）

        // URLを構築
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type",
                    "application/x-www-form-urlencoded");

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

            // リクエストを送信
            DataOutputStream wr = new DataOutputStream(
                    connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // レスポンスを取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

**URLを介して別の場所でホストされている画像を追加する：**

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

public class UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 画像URLを置き換えてください
        String API_KEY = ""; // あなたのAPIキー
        String DATASET_NAME = "your-dataset"; // データセット名を設定（データセットURLで確認できます）

        // アップロードURL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

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

            // リクエストを送信
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // レスポンスを取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

{% endtab %}
{% endtabs %}

### 画像の詳細を取得する

REST APIを使って、特定の画像の詳細を取得できます。

特定の画像の詳細を取得するには、次のAPIエンドポイントに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'
```

このエンドポイントは、画像に関する次の情報を含む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[]
    }
}
```

### データセットから画像を削除する

REST APIを使って、データセットから画像を削除できます。

{% tabs %}
{% tab title="REST API" %}
データセットから画像を削除するには、次のAPIエンドポイントにDELETEリクエストを送信し、エンドポイントに画像IDを渡します。

```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"]}'
```

このエンドポイントは、操作が成功した場合204ステータスを返します。
{% endtab %}
{% endtabs %}

### 画像タグの一覧表示、追加、削除

REST APIを使って、Roboflow上の特定の画像にタグを割り当てられます

{% tabs %}
{% tab title="REST API" %}
Roboflow上でホストされている画像にタグを追加、削除、設定するには、次のAPIエンドポイントにPOSTリクエストを送信します。画像名に関連付けられた画像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,
     
     // タグの文字列配列
     "tags": string[],
     
}
```

APIは、Roboflow内の指定画像にタグを追加します（POSTリクエストには画像名ではなく画像IDを渡すことを忘れないでください）。
{% endtab %}
{% endtabs %}

### 画像メタデータとタグを更新する

REST APIを使って、ワークスペース内の画像にカスタムメタデータとタグを書き込めます。エンドポイントは2つあります。1つは単一画像を同期的に更新するためのもの、もう1つは最大1,000枚をバッチで更新するためのものです。

どちらのエンドポイントにも次のスコープを持つAPIキーが必要です: `image:tag` スコープ。

#### リクエスト本文

両方のエンドポイントは同じフィールドを受け付けます（バッチエンドポイントではそれらを `updates` 配列で包みます）:

```
- imageId（文字列） - バッチ更新では本文で必須、単一更新ではパスから推論されます
- metadata（オブジェクト） - 画像のユーザーメタデータに設定するキーと値のペア。
- removeMetadata（string[]） - 画像から削除するメタデータキー。
- addTags（string[]） - 画像に追加するタグ。
- removeTags（string[]） - 画像から削除するタグ。
```

これらのフィールドのうち少なくとも1つを含める必要があります。同じリクエストで同じメタデータキーやタグを設定と削除の両方に使うことはできません。 `_rf_internal_` で始まるメタデータキーはRoboflow用に予約されており、拒否されます。

#### 単一画像

単一画像のメタデータとタグを更新します。

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

#### バッチ更新

複数の画像のメタデータとタグを非同期で更新します。1リクエストあたり最大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` タスクID付きで返します。進捗確認のため、タスクURLをポーリングしてください。

```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) タスク状態のポーリング方法について。

#### エラー

```
- 400 - 空の本文、フィールド型の不正、または競合するフィールド（例: metadataとremoveMetadataの両方に同じキーがある）。
- 404 - ワークスペース内に画像が見つかりません（単一画像エンドポイントのみ）。
```

## Python SDK

`プロジェクト` 一括 [`upload_dataset`](/datasets/ja/toappurdo/upload-a-dataset.md#python-sdk) の流れを補完する、画像ごとの操作を提供します。単一画像アップロードをより細かく制御したい場合、後から注釈を付けたい場合、またはストリームから画像を1枚ずつ取り込む場合に使います。

### 画像をアップロードする（注釈は任意）

`Project.upload()` は「適切に処理する」高レベルのヘルパーです。単一画像と一致する注釈ファイル（任意）を受け取り、両方を1回の呼び出しでプロジェクトに送ります。

```python
import roboflow

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

result = project.upload(
    image_path="./photo.jpg",
    annotation_path="./photo.xml",   # 任意; 対応するVOC / COCO / などの注釈
    split="train",                    # train | valid | test
    batch_name="ingest-2026-05",     # 任意; Web UIでアップロードをグループ化
    tag_names=["camera-A", "indoor"], # 任意; タグを適用
    is_prediction=False,              # モデル生成注釈でレビュー待ちの場合はTrueに設定
    num_retry_uploads=2,              # 一時的なアップロード失敗時に再試行
)
print(result)
```

`single_upload()` は、同じ引数を取り、画像と（指定されていれば）注釈の両方に対する生のAPIレスポンスを返す、より低レベルのバリアントです。

### 画像のみをアップロードする

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

注釈がまだ存在せず、画像がそのままラベラーに送られる場合に便利です。

### アップロード前に画像を検証する

`check_valid_image()` APIを呼び出さずに、Roboflowのローカルなサイズ/形式チェックを実行します:

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

### 既存の画像に注釈を付ける

`save_annotation()` プロジェクト内に既にある画像に対して注釈を投稿します。別の場所で作成したラベルを追加する場合や、モデル予測をground truthに昇格させる場合に便利です。

```python
project.save_annotation(
    image_id="<image-id>",
    annotation_path="./photo.xml",
    is_prediction=False,
    annotation_overwrite=True,    # 既存の注釈を置き換える
)
```

渡す `annotation_labelmap="./labelmap.yaml"` 注釈フォーマットで必要な場合に、クラスインデックスをクラス名にマッピングするためのものです。

〜で保存 `is_prediction=True` 画像をレビュージョブに移動できます。参照 [予測の保存先](/datasets/ja/toappurdo/upload-a-dataset.md#where-predictions-land).

### 画像のメタデータを取得する

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

画像のメタデータ、現在の分割、注釈ステータスを返します。

### 画像を削除

プロジェクトレベル（このプロジェクトに属する画像のみ削除します）:

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

ワークスペースレベル（どのプロジェクトから参照されているかにかかわらず画像を削除します。注意して使用してください）:

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

### v1.3.6+ のアップロードに関する注意

〜時点で `roboflow` 1.3.6 では、SDK は Pillow を使って再エンコードするのではなく、元の画像バイト列をアップロードします。これにより Web アップローダーとの整合性が戻り、Roboflow サーバーは SHA-256 によってアップロードを重複排除できるようになります。同じ画像を 2 回アップロードする自動化処理（たとえば複数のバッチに追加する場合）がある場合、2 回目のアップロードは追加のストレージクレジットを消費せずに成功します。

## CLI

CLI を使って、1 枚の画像と、そのオプションの注釈、タグ、またはメタデータをアップロードします。

```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/ja/toappurdo/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>