> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://api.qdrant.tech/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.qdrant.tech/_mcp/server.

# Get collection details

GET http://localhost:6333/collections/{collection_name}

Retrieves parameters from the specified collection.

Reference: https://api.qdrant.tech/api-reference/collections/get-collection

## Authentication

- `api-key` header (required) — API Key authentication via header

## Servers

- `http://localhost:6333` (http, default)
- `https://localhost:6333` (https)

## Request

### Path parameters

- `collection_name` (string, required) — Name of the collection to retrieve

## Response

### 200

successful operation

- `time` (double, optional) — Time spent to process this request
- `status` (string, optional)
- `result` (CollectionInfo, optional) — Current statistics and configuration of the collection

## Types

### CollectionInfo

Current statistics and configuration of the collection

- `status` (enum, required) — Current state of the collection. `Green` - all good. `Yellow` - optimization is running, `Red` - some operations failed and was not recovered
  - Allowed values: `green`, `yellow`, `grey`, `red`
- `optimizer_status` (OptimizersStatus, required) — Current state of the collection
- `segments_count` (integer, required) — Number of segments in collection. Each segment has independent vector as payload indexes
- `config` (CollectionConfig, required)
- `payload_schema` (map from string to PayloadIndexInfo, required) — Types of stored payload
- `vectors_count` (integer, optional, nullable) — DEPRECATED: Approximate number of vectors in collection. All vectors in collection are available for querying. Calculated as `points_count x vectors_per_point`. Where `vectors_per_point` is a number of named vectors in schema.
- `indexed_vectors_count` (integer, optional, nullable) — Approximate number of indexed vectors in the collection. Indexed vectors in large segments are faster to query, as it is stored in a specialized vector index.
- `points_count` (integer, optional, nullable) — Approximate number of points (vectors + payloads) in collection. Each point could be accessed by unique id.

### OptimizersStatus

Current state of the collection

### CollectionConfig

- `params` (CollectionParams, required)
- `hnsw_config` (HnswConfig, required) — Config of HNSW index
- `optimizer_config` (OptimizersConfig, required)
- `wal_config` (WalConfig, required)
- `quantization_config` (CollectionConfigQuantizationConfig, optional)

### PayloadIndexInfo

Display payload field type & index information

- `data_type` (enum, required) — All possible names of payload types
  - Allowed values: `keyword`, `integer`, `float`, `geo`, `text`, `bool`, `datetime`
- `points` (integer, required) — Number of points indexed with this index
- `params` (PayloadIndexInfoParams, optional)

### OptimizersStatus1

Something wrong happened with optimizers

- `error` (string, required)

### CollectionParams

- `vectors` (VectorsConfig, optional) — Vector params separator for single and multiple vector modes Single mode: \{ "size": 128, "distance": "Cosine" } or multiple mode: \{ "default": \{ "size": 128, "distance": "Cosine" } }
- `shard_number` (uint, optional) — Number of shards the collection has
- `sharding_method` (CollectionParamsShardingMethod, optional) — Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key
- `replication_factor` (uint, optional) — Number of replicas for each shard
- `write_consistency_factor` (uint, optional) — Defines how many replicas should apply the operation for us to consider it successful. Increasing this number will make the collection more resilient to inconsistencies, but will also make it fail if not enough replicas are available. Does not have any performance impact.
- `read_fan_out_factor` (uint, optional, nullable) — Defines how many additional replicas should be processing read request at the same time. Default value is Auto, which means that fan-out will be determined automatically based on the busyness of the local replica. Having more than 0 might be useful to smooth latency spikes of individual nodes.
- `on_disk_payload` (boolean, optional, default: false) — If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM.
- `sparse_vectors` (map from string to SparseVectorParams, optional, nullable) — Configuration of the sparse vector storage

### HnswConfig

Config of HNSW index

- `m` (integer, required) — Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.
- `ef_construct` (integer, required) — Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build index.
- `full_scan_threshold` (integer, required) — Minimal size (in KiloBytes) of vectors for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold_kb` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required. Note: 1Kb = 1 vector of size 256
- `max_indexing_threads` (integer, optional, default: 0) — Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of slow building or broken/inefficient HNSW graphs. On small CPUs, less threads are used.
- `on_disk` (boolean, optional, nullable) — Store HNSW index on disk. If set to false, index will be stored in RAM. Default: false
- `payload_m` (integer, optional, nullable) — Custom M param for hnsw graph built for payload index. If not set, default M will be used.

### OptimizersConfig

- `deleted_threshold` (double, required) — The minimal fraction of deleted vectors in a segment, required to perform segment optimization
- `vacuum_min_vector_number` (integer, required) — The minimal number of vectors in a segment, required to perform segment optimization
- `default_segment_number` (integer, required) — Target amount of segments optimizer will try to keep. Real amount of segments may vary depending on multiple parameters: - Amount of stored points - Current write RPS It is recommended to select default number of segments as a factor of the number of search threads, so that each segment would be handled evenly by one of the threads. If `default_segment_number = 0`, will be automatically selected by the number of available CPUs.
- `flush_interval_sec` (uint64, required) — Minimum interval between forced flushes.
- `max_segment_size` (integer, optional, nullable) — Do not create segments larger this size (in kilobytes). Large segments might require disproportionately long indexation times, therefore it makes sense to limit the size of segments. If indexing speed is more important - make this parameter lower. If search speed is more important - make this parameter higher. Note: 1Kb = 1 vector of size 256 If not set, will be automatically selected considering the number of available CPUs.
- `memmap_threshold` (integer, optional, nullable) — Maximum size (in kilobytes) of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmaped file. Memmap storage is disabled by default, to enable it, set this threshold to a reasonable value. To disable memmap storage, set this to `0`. Internally it will use the largest threshold possible. Note: 1Kb = 1 vector of size 256
- `indexing_threshold` (integer, optional, nullable) — Maximum size (in kilobytes) of vectors allowed for plain index, exceeding this threshold will enable vector indexing Default value is 20,000, based on \<[https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md>](https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md>). To disable vector indexing, set to `0`. Note: 1kB = 1 vector of size 256.
- `max_optimization_threads` (integer, optional, nullable) — Max number of threads (jobs) for running optimizations per shard. Note: each optimization job will also use `max_indexing_threads` threads by itself for index building. If null - have no limit and choose dynamically to saturate CPU. If 0 - no optimization threads, optimizations will be disabled.

### WalConfig

- `wal_capacity_mb` (integer, required) — Size of a single WAL segment in MB
- `wal_segments_ahead` (integer, required) — Number of WAL segments to create ahead of actually used ones

### CollectionConfigQuantizationConfig

### PayloadIndexInfoParams

### VectorsConfig

Vector params separator for single and multiple vector modes Single mode: \{ "size": 128, "distance": "Cosine" } or multiple mode: \{ "default": \{ "size": 128, "distance": "Cosine" } }

### CollectionParamsShardingMethod

Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key

### SparseVectorParams

Params of single sparse vector data storage

- `index` (SparseVectorParamsIndex, optional) — Custom params for index. If none - values from collection configuration are used.
- `modifier` (SparseVectorParamsModifier, optional) — Configures addition value modifications for sparse vectors. Default: none

### VectorParams

Params of single vector data storage

- `size` (uint64, required) — Size of a vectors used
- `distance` (enum, required) — Type of internal tags, build from payload Distance function types used to compare vectors
  - Allowed values: `Cosine`, `Euclid`, `Dot`, `Manhattan`
- `hnsw_config` (VectorParamsHnswConfig, optional) — Custom params for HNSW index. If none - values from collection configuration are used.
- `quantization_config` (VectorParamsQuantizationConfig, optional) — Custom params for quantization. If none - values from collection configuration are used.
- `on_disk` (boolean, optional, nullable) — If true, vectors are served from disk, improving RAM usage at the cost of latency Default: false
- `datatype` (VectorParamsDatatype, optional) — Defines which datatype should be used to represent vectors in the storage. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are stored as unsigned 8-bit integers, 1 byte. It expects vector elements to be in range `[0, 255]`.
- `multivector_config` (VectorParamsMultivectorConfig, optional)

### SparseVectorParamsIndex

Custom params for index. If none - values from collection configuration are used.

### SparseVectorParamsModifier

Configures addition value modifications for sparse vectors. Default: none

### VectorParamsHnswConfig

Custom params for HNSW index. If none - values from collection configuration are used.

### VectorParamsQuantizationConfig

Custom params for quantization. If none - values from collection configuration are used.

### VectorParamsDatatype

Defines which datatype should be used to represent vectors in the storage. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are stored as unsigned 8-bit integers, 1 byte. It expects vector elements to be in range `[0, 255]`.

### VectorParamsMultivectorConfig

### SparseIndexParams

Configuration for sparse inverted index.

- `full_scan_threshold` (integer, optional, nullable) — We prefer a full scan search upto (excluding) this number of vectors. Note: this is number of vectors, not KiloBytes.
- `on_disk` (boolean, optional, nullable) — Store index on disk. If set to false, the index will be stored in RAM. Default: false
- `datatype` (SparseIndexParamsDatatype, optional) — Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range.

### HnswConfigDiff

- `m` (integer, optional, nullable) — Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.
- `ef_construct` (integer, optional, nullable) — Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build the index.
- `full_scan_threshold` (integer, optional, nullable) — Minimal size (in kilobytes) of vectors for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold_kb` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required. Note: 1Kb = 1 vector of size 256
- `max_indexing_threads` (integer, optional, nullable) — Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of building broken/inefficient HNSW graphs. On small CPUs, less threads are used.
- `on_disk` (boolean, optional, nullable) — Store HNSW index on disk. If set to false, the index will be stored in RAM. Default: false
- `payload_m` (integer, optional, nullable) — Custom M param for additional payload-aware HNSW links. If not set, default M will be used.

### MultiVectorConfig

- `comparator` (enum, required)
  - Allowed values: `max_sim`

### SparseIndexParamsDatatype

Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range.

## Examples

**Response**

```json
{
  "time": 1.1,
  "status": "string",
  "result": {
    "status": "green",
    "optimizer_status": "ok",
    "segments_count": 1,
    "config": {
      "params": {
        "vectors": {},
        "shard_number": 1,
        "sharding_method": "auto",
        "replication_factor": 1,
        "write_consistency_factor": 1,
        "read_fan_out_factor": 1,
        "on_disk_payload": false,
        "sparse_vectors": {}
      },
      "hnsw_config": {
        "m": 1,
        "ef_construct": 1,
        "full_scan_threshold": 1,
        "max_indexing_threads": 0,
        "on_disk": true,
        "payload_m": 1
      },
      "optimizer_config": {
        "deleted_threshold": 1.1,
        "vacuum_min_vector_number": 1,
        "default_segment_number": 1,
        "flush_interval_sec": 1,
        "max_segment_size": 1,
        "memmap_threshold": 1,
        "indexing_threshold": 1,
        "max_optimization_threads": 1
      },
      "wal_config": {
        "wal_capacity_mb": 1,
        "wal_segments_ahead": 1
      },
      "quantization_config": {
        "scalar": {
          "type": "int8",
          "quantile": 1.1,
          "always_ram": true
        }
      }
    },
    "payload_schema": {},
    "vectors_count": 1,
    "indexed_vectors_count": 1,
    "points_count": 1
  }
}
```

**SDK Code**

```rust
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;

client.collection_info("{collection_name}").await?;

```

```csharp
using Qdrant.Client;

var client = new QdrantClient("localhost", 6334);

await client.GetCollectionInfoAsync("{collection_name}");

```

```java
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;

QdrantClient client = new QdrantClient(
                QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client.getCollectionInfoAsync("{collection_name}").get();

```

```typescript
import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ host: "localhost", port: 6333 });

client.getCollection("{collection_name}");

```

```python
from qdrant_client import QdrantClient

client = QdrantClient(url="http://localhost:6333")

client.get_collection("{collection_name}")

```

```go
package main

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

func main() {

	url := "http://localhost:6333/collections/collection_name"

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

	req.Header.Add("api-key", "<apiKey>")

	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("http://localhost:6333/collections/collection_name")

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

request = Net::HTTP::Get.new(url)
request["api-key"] = '<apiKey>'

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

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'http://localhost:6333/collections/collection_name', [
  'headers' => [
    'api-key' => '<apiKey>',
  ],
]);

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

```swift
import Foundation

let headers = ["api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:6333/collections/collection_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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