> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/switch-infrastructure/config-manager/llms.txt.
> For full documentation content, see https://docs.nvidia.com/switch-infrastructure/config-manager/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/switch-infrastructure/config-manager/_mcp/server.

# Search devices by name with latest config info

GET https://host.com/v1/admin/devices/search

Search devices by name with their latest configuration metadata.

If q is not provided, returns the 100 most recently updated devices from DB.
If q is provided, uses Redis cache to find matching device names and their UUIDs,
then fetches their latest config info from DB.
Results are sorted by most recent update first.
Results are filtered by file_type (intended or backup).
Inactive devices (removed from nv_config_manager/Nautobot) are hidden unless include_inactive is True.

Reference: https://docs.nvidia.com/switch-infrastructure/config-manager/switch-infrastructure/config-manager/services/config-store/config-store-api/admin/search-devices-v-1-admin-devices-search-get

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: config-store-api
  version: 1.0.0
paths:
  /v1/admin/devices/search:
    get:
      operationId: search-devices-v-1-admin-devices-search-get
      summary: Search devices by name with latest config info
      description: >-
        Search devices by name with their latest configuration metadata.


        If q is not provided, returns the 100 most recently updated devices from
        DB.

        If q is provided, uses Redis cache to find matching device names and
        their UUIDs,

        then fetches their latest config info from DB.

        Results are sorted by most recent update first.

        Results are filtered by file_type (intended or backup).

        Inactive devices (removed from nv_config_manager/Nautobot) are hidden
        unless include_inactive is True.
      tags:
        - subpackage_admin
      parameters:
        - name: q
          in: query
          required: false
          schema:
            type:
              - string
              - 'null'
        - name: limit
          in: query
          required: false
          schema:
            type: integer
            default: 100
        - name: file_type
          in: query
          required: false
          schema:
            $ref: '#/components/schemas/FileType'
        - name: include_inactive
          in: query
          required: false
          schema:
            type: boolean
            default: false
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/DeviceLatestConfig'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
servers:
  - url: https://host.com
components:
  schemas:
    FileType:
      type: string
      enum:
        - intended
        - backup
      description: Enum for config file types.
      title: FileType
    DeviceLatestConfig:
      type: object
      properties:
        active:
          type: boolean
          default: true
          description: Whether the device is currently active in nv-config-manager
        latest_author:
          type: string
          description: Author of latest change
        latest_message:
          type: string
          description: Commit message of latest change
        latest_update:
          type: string
          description: Latest config update timestamp
        name:
          type: string
          description: Device name
        site:
          type: string
          description: Site name
        uuid:
          type: string
          description: Device UUID
      required:
        - latest_author
        - latest_message
        - latest_update
        - name
        - site
        - uuid
      description: Device with its latest config metadata.
      title: DeviceLatestConfig
    ValidationErrorCtx:
      type: object
      properties: {}
      title: ValidationErrorCtx
    ValidationErrorLocItems:
      oneOf:
        - type: string
        - type: integer
      title: ValidationErrorLocItems
    ValidationError:
      type: object
      properties:
        ctx:
          $ref: '#/components/schemas/ValidationErrorCtx'
        input:
          description: Any type
        loc:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorLocItems'
        msg:
          type: string
        type:
          type: string
      required:
        - loc
        - msg
        - type
      title: ValidationError
    HTTPValidationError:
      type: object
      properties:
        detail:
          type: array
          items:
            $ref: '#/components/schemas/ValidationError'
      title: HTTPValidationError

```

## SDK Code Examples

```python
import requests

url = "https://host.com/v1/admin/devices/search"

payload = {}
headers = {"Content-Type": "application/json"}

response = requests.get(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://host.com/v1/admin/devices/search';
const options = {method: 'GET', headers: {'Content-Type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://host.com/v1/admin/devices/search"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("GET", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://host.com/v1/admin/devices/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://host.com/v1/admin/devices/search")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://host.com/v1/admin/devices/search', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://host.com/v1/admin/devices/search");
var request = new RestRequest(Method.GET);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://host.com/v1/admin/devices/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```