> 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-datasets/dataset-search.md).

# डेटासेट खोजें

## के बारे में

डेटासेट खोज आपको फ़ाइल-नाम लुकअप, संरचित फ़िल्टर (टैग, स्प्लिट, क्लास, आयाम, एनोटेशन गणना), बूलियन लॉजिक, और प्राकृतिक-भाषा अर्थगत खोज का उपयोग करके किसी प्रोजेक्ट में विशिष्ट छवियाँ ढूँढने देती है। इसका उपयोग अपने डेटा का ऑडिट करने, गलत लेबल वाली या गायब एनोटेशन पहचानने, और समीक्षा या निर्यात के लिए लक्षित उपसमुच्चय बनाने में करें। वही क्वेरीज़ वेब ऐप और खोज REST API दोनों में उपलब्ध हैं।

## वेब ऐप

आप Roboflow में फ़ाइल नाम, एक खोज क्वेरी, और क्वेरीज़ तथा फ़िल्टरों को मिलाकर विशिष्ट छवियाँ खोज सकते हैं और अपने डेटा को बेहतर समझ सकते हैं।

* **एक निश्चित टैग वाले किसी स्प्लिट में छवियाँ:**\
  `tag:factory split:train`\
  यह एक टैग फ़िल्टर और एक स्प्लिट फ़िल्टर का उपयोग करता है
* **अर्थगत खोज और क्लास फ़िल्टर का उपयोग करके गायब लेबल खोजें**:\
  `person -class:helmet`\
  यह एक क्लास फ़िल्टर पर अर्थगत खोज और उल्टे फ़िल्टर का उपयोग करता है
* **यदि किसी क्लास वाली सभी छवियों को किसी निश्चित फ़िल्टर की आवश्यकता हो:**\
  `class:helmet AND NOT (tag:v1 OR tag:v2)`\
  यह क्लास फ़िल्टर, बूलियन लॉजिक, और टैग फ़िल्टरों का उपयोग करता है
* **कम एनोटेशन संख्या वाली चौड़ी छवियाँ खोजें:**\
  `min-width:1000 max-annotations:1`\
  यह न्यूनतम चौड़ाई फ़िल्टर और अधिकतम एनोटेशन संख्या फ़िल्टर का उपयोग करता है

पूर्ण सूची देखें [खोज फ़िल्टरों की](#search-filters), साथ ही नीचे दिए गए उदाहरण भी

{% hint style="info" %}
आप इन सभी खोज फ़िल्टरों और क्वेरीज़ को एक साथ मिला सकते हैं
{% endhint %}

### अर्थगत खोज

आप छवियों का वर्णन करके उनकी खोज कर सकते हैं। ये क्वेरीज़ आपकी खोज शर्तों से सबसे अधिक संबंधित छवियों को खोजेंगी और तब भी छवियाँ ढूँढने में मदद कर सकती हैं जब वस्तुएँ अभी लेबल न की गई हों।

अर्थगत खोज तब होती है जब आप किसी फ़िल्टर चयनक के बिना एक टेक्स्ट क्वेरी दर्ज करते हैं (उदा.: `filename:`)

<figure><img src="/files/a8c0adebe8f219a7d29e189db4617663d5d0785b" alt=""><figcaption></figcaption></figure>

### फ़ाइल नाम से खोजें

आप `filename:` फ़िल्टर या फ़ाइल नाम टेक्स्टबॉक्स का उपयोग करके फ़ाइल नाम खोज सकते हैं, जो आपके लिए क्वेरी बनाएगा।

<figure><img src="/files/68e5a584eaf3eb3380984a0fb98d52d45363f6c2" alt="" width="192"><figcaption></figcaption></figure>

### डेटासेट स्प्लिट के आधार पर खोजें

डेटासेट स्प्लिट (train, valid, test) के आधार पर छवियाँ खोजें

<figure><img src="/files/29ab3ce9da35dfcaacab024a26c62993b58796e9" alt="" width="257"><figcaption></figcaption></figure>

छवियों को किसी अलग स्प्लिट में पुनः असाइन करने के लिए, उन्हें चुनें (या खोज में "Select all matching" चुनें) और बल्क क्रियाएँ मेनू में "Change Dataset Split" पर क्लिक करें। बड़े चयन पृष्ठभूमि में संसाधित होते हैं।

### अपलोड तिथि के आधार पर खोजें

छवियों को उस तिथि के आधार पर फ़िल्टर करें जिस दिन उन्हें पहली बार Roboflow पर अपलोड किया गया था, का उपयोग करके `date:` फ़िल्टर। अपलोड तिथि अपरिवर्तनीय है और जब किसी छवि को संपादित, पुनः एनोटेट या स्प्लिटों के बीच स्थानांतरित किया जाता है, तब नहीं बदलती।

का उपयोग करें `date:YYYY-MM-DD` किसी सटीक दिन के लिए, या एक सीमा खोजने के लिए तुलना ऑपरेटरों को मिलाएँ:

`date>=2026-01-01 date<2026-02-01`

### खोज फ़िल्टर

यहाँ उपलब्ध फ़िल्टर हैं:

* `like-image:<IMAGE_ID>`: छवि सामग्री पर आधारित अर्थगत खोज
* `tag` : उपयोगकर्ता द्वारा प्रदान किए गए टैगों द्वारा फ़िल्टर करें।
* `filename` : दिए गए फ़ाइल नाम से मेल खाने वाले फ़ाइल नामों की खोज चलाता है। आंशिक मिलान चलाने के लिए क्वेरी की शुरुआत और अंत में \* का उपयोग करें।
* `split` : स्प्लिट (train, test, valid) के आधार पर फ़िल्टर करता है।
* `job:<JOB_ID>` : दिए गए जॉब ID वाली छवियाँ दिखाता है।
* `min-width:X` : X से अधिक चौड़ाई वाली छवियाँ दिखाता है।
* `max-width:X` : X से कम चौड़ाई वाली छवियाँ दिखाता है।
* `min-height:X` : X से अधिक ऊँचाई वाली छवियाँ दिखाता है।
* `max-height:X` : X से कम ऊँचाई वाली छवियाँ दिखाता है।
* `min-annotations:X` : निर्दिष्ट एनोटेशन संख्या से अधिक वाली छवियों को फ़िल्टर करता है।
* `max-annotations:X` : निर्दिष्ट एनोटेशन संख्या से कम वाली छवियाँ दिखाता है।
* `class:CLASS`: प्रदान किए गए लेबल के साथ कम-से-कम 1 एनोटेशन वाली छवियाँ दिखाता है।
* `date:YYYY-MM-DD` : एक छवि के अपलोड किए जाने की अपरिवर्तनीय तिथि के आधार पर फ़िल्टर करता है। तुलना ऑपरेटरों का समर्थन करता है (उदा.: `date>=2026-01-01 date<2026-02-01`).

#### बूलियन लॉजिक

कई फ़िल्टरों को जोड़कर जटिल क्वेरी बनाने के लिए AND, OR, NOT, और कोष्ठकों का उपयोग करें।

`class:helmet AND NOT (tag:v1 OR tag:v2)`

#### उल्टे फ़िल्टर

फ़िल्टर से मेल खाने वाली छवियों को बाहर करने के लिए फ़िल्टर के पहले माइनस चिह्न जोड़ें।

`class:helmet -class:vest`

#### संख्यात्मक क्लास फ़िल्टर

किसी छवि में लेबल किए गए आइटमों की संख्या के आधार पर फ़िल्टर करें।

`class:helmet=3 class:vest>=4`

### एपीआई

आप इसके माध्यम से Roboflow पर अपने डेटासेट और छवियों को भी खोज सकते हैं [खोज API](#http-api).

## HTTP एपीआई

आप REST API का उपयोग करके Roboflow पर होस्ट की गई छवियों की खोज कर सकते हैं। दो एंडपॉइंट हैं: एक प्रोजेक्ट-स्कोप्ड `/:workspace/:project/search` एंडपॉइंट, और एक वर्कस्पेस-व्यापी `/:workspace/search/v1` एंडपॉइंट, जो [वेब ऐप डेटासेट खोज](#web-app).

### प्रोजेक्ट में छवियाँ खोजें

Roboflow पर होस्ट की गई छवियों को खोजने के लिए, निम्न API एंडपॉइंट पर POST अनुरोध करें:

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

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

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project-name/search?api_key=$ROBOFLOW_API_KEY" \
-H 'Content-Type: application/json' \
--data \
'{
    "like_image": "image_id",
    "in_dataset": true,
    "limit": 125
}'
```

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

```json
{
     // जब प्रदान किया जाए, तो परिणाम अर्थगत समानता के अनुसार क्रमबद्ध रूप में देता है
     "like_image": स्ट्रिंग,
     
     // जब प्रदान किया जाए, तो परिणाम अर्थगत समानता के अनुसार क्रमबद्ध रूप में देता है
     "prompt": स्ट्रिंग,
     
     // डिफ़ॉल्ट 0
     "offset": int,
     
     // डिफ़ॉल्ट 50 (अधिकतम: 250)
     "limit": int,
     
     // मौजूद होने पर, प्रदान किए गए टैग वाली छवियों को फ़िल्टर करता है
     "tag": string,
     
     // मौजूद होने पर, प्रदान किए गए क्लास नाम वाली छवियों को फ़िल्टर करता है
     "class_name": string,
     
     // मौजूद होने पर, प्रदान किए गए प्रोजेक्ट में मौजूद छवियों को फ़िल्टर करता है
     "in_dataset": string,
     
     // मौजूद होने पर, केवल किसी भी बैच में मौजूद छवियाँ लौटाता है
     "batch": boolean,
     
     // मौजूद होने पर, केवल प्रदान किए गए बैच में मौजूद छवियाँ लौटाता है
     "batch_id": string,

     // मौजूद होने पर, केवल किसी भी एनोटेशन जॉब में मौजूद छवियाँ लौटाता है
     "annotation_job": boolean,

     // मौजूद होने पर, केवल प्रदान किए गए एनोटेशन जॉब में मौजूद छवियाँ लौटाता है
     "annotation_job_id": string,
     
     // लौटाने के लिए फ़ील्ड निर्दिष्ट करें, डिफ़ॉल्ट ["id", "created"]
     // विकल्प हैं ["id", "name", "annotations", "labels", "split", "tags", "owner", "url", "embedding", "created"]
     "fields": string[]
}
```

खोज API निम्न संरचना वाली प्रतिक्रिया लौटाएगा। उपलब्ध मान आपके द्वारा निर्दिष्ट अतिरिक्त `फ़ील्ड्स` पर निर्भर करेंगे:

```json
{
    "offset": 0,
    "total": 292,
    "results": [
        {
            "id": "image123",
            "name": "humpbackwhale.jpg",
            "owner": "owner123",
            "url": "https://source.roboflow.com/owner123/image123/original.jpg",
            "annotations": {
                "count": 5,
                "classes": {
                    "whale": 1,
                    "fish": 4
                }
            },
            "labels": [],
            "tags": [
                "cam_x13"
            ]
        }
        // ... आदि.
    ]
}
```

### वर्कस्पेस में छवियाँ खोजें

Workspace Image Search API आपको अपने वर्कस्पेस के भीतर छवियों की सूची बनाने और खोजने देता है।

इस API के साथ, आप फ़िल्टर, सॉर्ट, और एक क्वेरी स्ट्रिंग का उपयोग करके अर्थगत खोज कर सकते हैं जो समान है [Roboflow वेब एप्लिकेशन में छवि खोज सुविधा से](#web-app).

#### एंडपॉइंट

API पर अनुरोध करने के लिए, एक `POST` अनुरोध निम्न एंडपॉइंट पर भेजें:

```
https://api.roboflow.com/{WORKSPACE}/search/v1?api_key=API_KEY
```

जहाँ `WORKSPACE` आपका Workspace ID है, और `API_KEY` आपकी API कुंजी है।

[अपना Workspace ID कैसे खोजें, यह जानें](https://docs.roboflow.com/reference/authentication/authentication/workspace-and-project-ids).

[अपनी API कुंजी कैसे खोजें, यह जानें।](https://docs.roboflow.com/reference/platform/rest-api/authenticate-with-the-rest-api)

#### प्रमाणीकरण

API तक पहुँचने के लिए, आपको अनुरोध में अपनी API कुंजी शामिल करनी होगी। API कुंजी को क्वेरी पैरामीटर के रूप में पास किया जाना चाहिए।

उदाहरण: `?api_key={YOUR_API_KEY}`

#### अनुरोध प्रारूप

**हेडर**

* `Content-Type: application/json`

**बॉडी पैरामीटर**

* `query` **(आवश्यक)**: फ़िल्टर, सॉर्ट, या अर्थगत खोज करने के लिए एक गैर-खाली स्ट्रिंग। उदाहरण के लिए: `"nighttime project:{my-project-url}"` छवियों को `my-project-url` प्रोजेक्ट में फ़िल्टर करेगा और उन छवियों के लिए अर्थगत सॉर्ट लागू करेगा जो `nighttime`. यदि गायब या खाली हो तो 400 त्रुटि लौटाता है।
* `pageSize`: प्रति पृष्ठ लौटाए जाने वाले परिणामों की संख्या (डिफ़ॉल्ट: 50)।
* `फ़ील्ड्स`: प्रतिक्रिया में शामिल किए जाने वाले फ़ील्डों की सूची। संभावित मान हैं `"tags"`, `"width"`, `"height"`, `"filename"`, `"aspectRatio"`, `"split"`, `"projects"`, `"annotations"`, `"labels"`, `"owner"`, `"url"`.

**उदाहरण अनुरोध**

```bash
curl --location 'https://api.roboflow.com/{WORKSPACE}/search/v1?api_key={API_KEY}' \
--header 'Content-Type: application/json' \
--data '{
    "query": "project:foo nightime",
    "pageSize": 10,
    "fields": ["tags", "width", "height", "filename", "aspectRatio", "split"]
}'

```

#### प्रतिक्रिया प्रारूप

प्रतिक्रिया एक JSON ऑब्जेक्ट है जिसमें निम्न फ़ील्ड शामिल हैं:

* `results`: छवि ऑब्जेक्ट्स की एक सरणी।
* `total`: मिली छवियों की कुल संख्या।
* `continuationToken`: पेजिनेशन के लिए एक टोकन।

**छवि ऑब्जेक्ट फ़ील्ड्स**

अनुरोधित फ़ील्डों के आधार पर `फ़ील्ड्स` पैरामीटर:

* `id`: छवि का अद्वितीय पहचानकर्ता।
* `projectData`: प्रोजेक्ट URL द्वारा कुंजीबद्ध ऑब्जेक्ट, जिसमें प्रोजेक्ट-विशिष्ट डेटा शामिल है:
  * `split`: डेटासेट स्प्लिट को दर्शाता है (उदा., "test"). तब लौटाया जाता है जब `"split"` में है `फ़ील्ड्स`.
  * `inDataset`: छवि के डेटासेट में होने का संकेत देने वाला बूलियन। तब लौटाया जाता है जब `"projects"` में है `फ़ील्ड्स`.
  * `annotations`: इस प्रोजेक्ट में छवि के लिए एनोटेशन डेटा, जिसमें `annotationGroup`, `classes`, और `classCounts`. तब लौटाया जाता है जब `"annotations"` में है `फ़ील्ड्स`.
  * `labels`: इस प्रोजेक्ट में छवि के लिए लेबल डेटा। तब लौटाया जाता है जब `"labels"` में है `फ़ील्ड्स`.
* `tags`: छवि से संबद्ध टैगों की सरणी।
* `width`: पिक्सेल में छवि की चौड़ाई।
* `height`: पिक्सेल में छवि की ऊँचाई।
* `filename`: छवि फ़ाइल का नाम।
* `aspectRatio`: छवि का आस्पेक्ट रेशियो।
* `owner`: छवि का स्वामी पहचानकर्ता।
* `url`: मूल छवि फ़ाइल का सीधा URL।

**पेजिनेशन और `continuationToken`**

यह `continuationToken` प्रतिक्रिया में लौटाया गया आपको खोज परिणाम से मेल खाने वाले पृष्ठों के बीच स्क्रॉल करने देता है। जब `continuationToken` अगले अनुरोध में शामिल किया जाता है, तो यह परिणामों का अगला सेट प्राप्त करता है।

का उपयोग करने के लिए `continuationToken`, इसे अपने अगले API कॉल के अनुरोध बॉडी में शामिल करें। यह आपकी मूल क्वेरी के आधार पर परिणामों का अगला पृष्ठ पुनः प्राप्त करेगा।

**त्रुटि प्रतिक्रियाएँ**

* `400` - तब लौटाया जाता है जब `query` गायब या खाली हो, या जब एक `project:` फ़िल्टर ऐसे प्रोजेक्ट का संदर्भ देता है जो आपके वर्कस्पेस से संबंधित नहीं है।
* `500` - आंतरिक सर्वर त्रुटि।

**प्रोजेक्ट और डेटासेट फ़िल्टर**

में उपलब्ध सभी फ़िल्टरों के अतिरिक्त [ऐप में डेटासेट खोज](#web-app), वर्कस्पेस-व्यापी खोज भी `प्रोजेक्ट` और `डेटासेट` . उदाहरण के लिए आप इस तरह की क्वेरी का उपयोग कर सकते हैं `project:foo project:bar` दोनों प्रोजेक्टों में मौजूद सभी छवियाँ खोजने के लिए `foo` और `bar`.\
\
इस तरह की क्वेरी `dataset:foo`प्रोजेक्ट में छवियाँ लौटाएगी `foo` जिन्हें लेबल किया गया है और प्रोजेक्ट के डेटासेट में जोड़ा गया है।

## Python SDK

`Project.search_all()` प्रोजेक्ट में छवियों पर खोज परिणामों का पेजिनेटेड iterator लौटाता है। खोज मोडों को जोड़ा जा सकता है: क्लास द्वारा सीमित टेक्स्ट प्रॉम्प्ट, किसी एक बैच तक सीमित मौजूदा छवि समानता खोज, आदि।

```python
import roboflow

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

records = []
for page in project.search_all(
    prompt="mug on a desk",
    class_name="mug",
    in_dataset="my-detector",
    limit=100,
    fields=["id", "created", "name", "labels"],
):
    records.extend(page)

print(len(records))
```

### पैरामीटर

* `प्रॉम्प्ट` (str, वैकल्पिक) - प्राकृतिक-भाषा खोज प्रॉम्प्ट (CLIP एम्बेडिंग के माध्यम से अर्थगत खोज)।
* `like_image` (str, वैकल्पिक) - टेक्स्ट के बजाय दृश्य समानता से खोजने के लिए छवि id।
* `tag` (str, वैकल्पिक) - केवल इस टैग वाली छवियाँ।
* `class_name` (str, वैकल्पिक) - केवल वे छवियाँ जिनमें इस क्लास में एनोटेशन है।
* `in_dataset` (str, वैकल्पिक) - उस डेटासेट का नाम जिससे एक छवि संबंधित होनी चाहिए (उस डेटासेट की छवियों तक सीमित करता है, batch / annotation-job staging क्षेत्रों को छोड़कर)।
* `batch` (bool, वैकल्पिक) और `batch_id` (str, वैकल्पिक) - किसी विशिष्ट अपलोड बैच तक सीमित करें।
* `annotation_job` (bool, केवल kw) और `annotation_job_id` (str, केवल kw) - किसी विशिष्ट एनोटेशन जॉब तक सीमित करें।
* `offset` (int, डिफ़ॉल्ट `0`) - पेजिनेशन ऑफ़सेट।
* `limit` (int, डिफ़ॉल्ट `100`) - पृष्ठ आकार।
* `फ़ील्ड्स` (list\[str], वैकल्पिक) - प्रतिक्रिया आकार कम करने के लिए प्रति परिणाम केवल सूचीबद्ध फ़ील्ड अनुरोध करें।

`search_all()` एक जनरेटर है - प्रत्येक पुनरावृत्ति में अधिकतम `limit` परिणामों का एक पृष्ठ देता है, और ऑफ़सेट स्वतः आगे बढ़ाता है। एक एकल-पृष्ठ, one-shot कॉल के लिए, `project.search(...)` का उपयोग वही आर्गुमेंट्स के साथ करें।

### वर्कस्पेस-व्यापी खोज

वर्कस्पेस के हर प्रोजेक्ट में खोजने के लिए, `Workspace.search()` / `Workspace.search_all()`. प्रोजेक्ट-प्रति-प्रोजेक्ट विधियों के विपरीत, ये एक एकल RoboQL `query` स्ट्रिंग लेते हैं (उदाहरण के लिए `"class:forklift"`, `"tag:review"`, या semantic CLIP search के लिए मुक्त पाठ) के साथ-साथ वैकल्पिक `page_size` और `फ़ील्ड्स`. प्रत्येक प्राप्त पृष्ठ परिणाम पंक्तियों की एक सूची होता है, और पंक्तियों में एक के अंतर्गत स्रोत प्रोजेक्ट शामिल होता है `प्रोजेक्ट्स` फ़ील्ड.

```python
records = []
for page in rf.workspace().search_all(query="class:forklift"):
    records.extend(page)
```

### खोज परिणामों को डाउनलोड करने योग्य डेटासेट के रूप में निर्यात करें

`Workspace.search_export()` एक खोज चलाता है और परिणामों को डाउनलोड करने योग्य डेटासेट (COCO / YOLO / VOC आदि) के रूप में पैकेज करता है। देखें [डेटा निर्यात करें (REST)](/datasets/hi/versions/dataset-versions/exporting-data.md#http-api) अंतर्निहित एंडपॉइंट के लिए।

```python
path = rf.workspace().search_export(
    query="forklift",
    format="coco",
    location="./forklift-search",
)
print(path)
```

## CLI

आप अपने वर्कस्पेस में छवियों को खोज सकते हैं [RoboQL](/datasets/hi/manage/manage-datasets/dataset-search.md) और वैकल्पिक रूप से मिलते-जुलते परिणामों को डाउनलोड करने योग्य डेटासेट के रूप में निर्यात कर सकते हैं।

### खोज

```bash
roboflow search "<query>"
```

#### विकल्प

| ध्वज       | विवरण                                                     |
| ---------- | --------------------------------------------------------- |
| `--limit`  | लौटाए जाने वाले अधिकतम परिणाम (डिफ़ॉल्ट: 50)              |
| `--cursor` | पेजिनेशन के लिए निरंतरता टोकन                             |
| `--fields` | शामिल करने के लिए फ़ील्ड्स की अल्पविराम से अलग की गई सूची |

#### उदाहरण

किसी विशिष्ट टैग वाली छवियों को खोजें:

```bash
roboflow search "tag:reviewed"
```

किसी विशिष्ट क्लास वाली छवियों को खोजें:

```bash
roboflow search "class:person" --limit 100
```

### खोज परिणाम निर्यात करें

जोड़ें `--export` मिलती-जुलती छवियों को डेटासेट के रूप में डाउनलोड करने के लिए:

```bash
roboflow search "<query>" --export -f <format> -l <location>
```

#### निर्यात विकल्प

| ध्वज                       | विवरण                                       |
| -------------------------- | ------------------------------------------- |
| `--export`                 | निर्यात मोड सक्षम करें                      |
| `-f`, `--format`           | एनोटेशन प्रारूप (डिफ़ॉल्ट: coco)            |
| `-l`, `--location`         | निर्यात को सहेजने के लिए स्थानीय निर्देशिका |
| `-d`, `--dataset`          | किसी विशिष्ट प्रोजेक्ट तक सीमित करें        |
| `-g`, `--annotation-group` | किसी विशिष्ट एनोटेशन समूह तक सीमित करें     |
| `--name`                   | निर्यात के लिए वैकल्पिक नाम                 |
| `--no-extract`             | ज़िप फ़ाइल रखें, निष्कर्षण छोड़ें           |

#### उदाहरण

COCO प्रारूप में सभी समीक्षा की गई छवियाँ निर्यात करें:

```bash
roboflow search "tag:reviewed" --export -f coco -l ./reviewed-export
```

YOLOv8 प्रारूप में किसी विशिष्ट प्रोजेक्ट की छवियाँ निर्यात करें:

```bash
roboflow search "class:car" --export -d my-project -f yolov8 -l ./cars
```

### JSON आउटपुट

```bash
roboflow search "tag:reviewed" --json
```

```json
{
  "results": [...],
  "total": 42,
  "cursor": "next-page-token"
}
```

का उपयोग करें `कर्सर` मान पेजिनेशन के लिए:

```bash
roboflow search "tag:reviewed" --cursor "next-page-token" --json
```