RCSB PDB Search API

https://search.rcsb.org/
Admin
This API allows searching metadata such as molecule names, sequences, and experimental details for...
Tokens:87,905
Snippets:207
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Paginate Search Results (JSON)

Source: https://search.rcsb.org/index

Configures pagination for search results using the `start` and `rows` parameters within the `paginate` object in `request_options`. This example fetches 100 results starting from the first hit.

```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "attribute": "rcsb_polymer_entity.formula_weight",
      "operator": "greater",
      "value": 500
    }
  },
  "request_options": {
    "paginate": {
      "start": 0,
      "rows": 100
    }
  },
  "return_type": "polymer_entity"
}
```

--------------------------------

### RCSB PDB Search API - Example Query

Source: https://search.rcsb.org/query-editor_json=%7B%22query%22%3A%7B%22type%22%3A%22terminal%22%2C%22service%22%3A%22text%22%2_954129_ct_match%22%2C%22value%22%3A%22ELECTRON+MICROSCOPY%22%7D%7D%2C%22return_type%22%3A%22entry%22%7D

An example of a search query to find entries with experimental method 'ELECTRON MICROSCOPY'.

```APIDOC
## POST /websites/search_rcsb

### Description
Submits a search query to the RCSB PDB to find relevant entries based on specified criteria.

### Method
POST

### Endpoint
/websites/search_rcsb

### Parameters
#### Request Body
- **query** (object) - Required - The search query object specifying search criteria.
  - **type** (string) - Required - Type of the query (e.g., 'terminal').
  - **service** (string) - Required - The service to use for the query (e.g., 'text').
  - **parameters** (object) - Required - Parameters for the query.
    - **attribute** (string) - Required - The attribute to search against (e.g., 'exptl.method').
    - **operator** (string) - Required - The matching operator (e.g., 'exact_match').
    - **value** (string) - Required - The value to search for (e.g., 'ELECTRON MICROSCOPY').
- **return_type** (string) - Required - The type of data to return (e.g., 'entry').

### Request Example
```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "attribute": "exptl.method",
      "operator": "exact_match",
      "value": "ELECTRON MICROSCOPY"
    }
  },
  "return_type": "entry"
}
```

### Response
#### Success Response (200)
- **results** (array) - A list of matching entries.

#### Response Example
```json
{
  "results": [
    {
      "pdb_id": "1ABC",
      "title": "Example Structure"
    },
    {
      "pdb_id": "2DEF",
      "title": "Another Example Structure"
    }
  ]
}
```
```

--------------------------------

### RCSB PDB Search API - Example Query

Source: https://search.rcsb.org/query-editor_json=%7B%22request_options%22%3A%7B%22paginate%22%3A%7B%22rows%22%3A0%7D%2C%22facet_498438_csb_entity_source_organism

This example demonstrates how to construct a query for the RCSB PDB Search API to retrieve entries and facet by organism names count.

```APIDOC
## POST /search

### Description
This endpoint allows you to perform complex searches against the RCSB PDB database. You can specify return types, pagination, and facets for aggregation.

### Method
POST

### Endpoint
/search

### Parameters
#### Query Parameters
None

#### Request Body
- **request_options** (object) - Required - Options for the search query, including pagination and facets.
  - **paginate** (object) - Optional - Pagination settings.
    - **rows** (integer) - Optional - Number of rows to return per page.
  - **facets** (array) - Optional - List of facets to apply to the search.
    - **name** (string) - Required - The name of the facet.
    - **aggregation_type** (string) - Required - The type of aggregation (e.g., 'cardinality').
    - **attribute** (string) - Required - The attribute to apply the facet to.
- **return_type** (string) - Required - The type of data to return (e.g., 'entry').

### Request Example
```json
{
  "request_options": {
    "paginate": {
      "rows": 0
    },
    "facets": [
      {
        "name": "Organism Names Count",
        "aggregation_type": "cardinality",
        "attribute": "rcsb_entity_source_organism.ncbi_scientific_name"
      }
    ]
  },
  "return_type": "entry"
}
```

### Response
#### Success Response (200)
- **response_data** (object) - Contains the search results and facets.
  - **rcsb_id** (string) - The RCSB ID of the entry.
  - **structures** (array) - Array of structure objects.
    - **pdb_id** (string) - The PDB ID.
    - **title** (string) - The title of the structure.
    - **organism_scientific_name** (string) - The scientific name of the organism.

#### Response Example
```json
{
  "query_result": {
    "total_count": 12345,
    "current_page": 0,
    "total_pages": 1,
    "entries": [
      {
        "rcsb_id": "1ABC",
        "struct_id": "1ABC",
        "title": "Example Protein Structure",
        "rcsb_entity_source_organism": [
          {
            "ncbi_scientific_name": "Homo sapiens"
          }
        ]
      }
    ]
  },
  "facets": [
    {
      "name": "Organism Names Count",
      "value": [
        {
          "value": "Homo sapiens",
          "count": 500
        }
      ]
    }
  ]
}
```
```

--------------------------------

### RCSB Search API GET Request Sample

Source: https://search.rcsb.org/redoc/index

This snippet demonstrates a sample JSON response for a successful GET request to the RCSB Search API. It includes information about the query, total results, and detailed breakdown of the results set, including facets and grouping options.

```json
{
  "query_id": "string",
  "result_type": "entry",
  "total_count": 1,
  "group_by_count": 1,
  "ungrouped_count": 1,
  "explain_metadata": {
    "total_timing": 0,
    "facet_timing": 0,
    "sort_timing": 0,
    "grouping_timing": 0,
    "terminal_node_timings": { }
  },
  "result_set": [
    "string"
  ],
  "facets": [
    {
      "name": "string",
      "buckets": [
        {
          "label": "string",
          "population": 0,
          "facets": [
            { }
          ]
        }
      ]
    }
  ],
  "group_by": {
    "aggregation_method": "matching_deposit_group_id",
    "ranking_criteria_type": {
      "sort_by": "score",
      "filter": {
        "type": "group",
        "logical_operator": "or",
        "nodes": [
          {
            "type": "terminal",
            "parameters": {
              "value": "string",
              "attribute": "string",
              "negation": false,
              "operator": "equals",
              "case_sensitive": false
            }
          }
        ]
      },
      "direction": "asc"
    }
  },
  "group_set": [
    "string"
  ]
}
```

--------------------------------

### Map Faceted Query Response Fields from v1 to v2

Source: https://search.rcsb.org/migration/migration-guide-v1-to-v2

This example illustrates the renaming of fields in the faceted query response from v1 to v2. `drilldown` is now `facets`, `groups` is `buckets`, `attribute` is `name`, and `distinct_count` is `value` for cardinality facets.

```json
{
  "drilldown": [
    {
      "attribute": "Terms",
      "groups": [
        {
          "label": "Bucket Key",
          "population": 100
        }
      ]
    },
    {
      "attribute": "Cardinality",
      "distinct_count": 10
    }
  ]
}
```

```json
{
  "facets": [
    {
      "name": "Terms",
      "buckets": [
        {
          "label": "Bucket Key",
          "population": 100
        }
      ]
    },
    {
      "name": "Cardinality",
      "value": 10
    }
  ]
}
```

--------------------------------

### Calculate PDB Structure Breakdown by Experimental Method (JSON)

Source: https://search.rcsb.org/index

This example demonstrates how to calculate the breakdown of PDB structures by their experimental method, filtering for structures released after a specific date. It returns both search hits and aggregation results.

```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "operator": "greater",
      "value": "2019-08-20",
      "attribute": "rcsb_accession_info.initial_release_date"
    }
  },
  "request_options": {
    "facets": [
      {
        "name": "Methods",
        "aggregation_type": "terms",
        "attribute": "exptl.method"
      }
    ]
  },
  "return_type": "entry"
}
```

--------------------------------

### Access Unreleased Data Search API (GET Request)

Source: https://search.rcsb.org/redoc/index

This example shows how to make a GET request to the unreleased data search API endpoint. The base URL is provided, and it's noted that query parameters must be URL-encoded. This endpoint allows textual searches against RCSB PDB unreleased entries.

```http
GET https://search.rcsb.org/rcsbsearch/v2/query/unreleased?query_parameters=URL_ENCODED_JSON_PAYLOAD
```

--------------------------------

### List Membrane Proteins

Source: https://search.rcsb.org/index

This example retrieves a list of PDB IDs for entries annotated as membrane proteins by various external resources. It uses a group query with the OR logical operator to combine results from different annotation types.

```json
{
  "query": {
    "type": "group",
    "logical_operator": "or",
    "nodes": [
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "attribute": "rcsb_polymer_entity_annotation.type",
          "operator": "exact_match",
          "value": "PDBTM"
        }
      },
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "attribute": "rcsb_polymer_entity_annotation.type",
          "operator": "exact_match",
          "value": "MemProtMD"
        }
      },
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "attribute": "rcsb_polymer_entity_annotation.type",
          "operator": "exact_match",
          "value": "OPM"
        }
      },
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "attribute": "rcsb_polymer_entity_annotation.type",
          "operator": "exact_match",
          "value": "mpstruc"
        }
      }
    ]
  },
  "return_type": "entry"
}
```

--------------------------------

### Retrieve All Search Hits (JSON)

Source: https://search.rcsb.org/index

Includes an example of how to retrieve all matching search hits by setting `return_all_hits` to `true` in the `request_options`. Use with caution due to potential performance issues.

```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "attribute": "rcsb_entry_info.selected_polymer_entity_types",
      "operator": "exact_match",
      "value": "Nucleic acid (only)"
    }
  },
  "request_options": {
    "return_all_hits": true
  },
  "return_type": "entry"
}
```

--------------------------------

### Search and Group Polymer Entities by Sequence Identity (JSON)

Source: https://search.rcsb.org/index

This example demonstrates how to search for polymer entities, group them by sequence identity (50% cutoff), and rank the entities within each group by a similarity score. It specifies minimal verbosity and returns groups.

```json
{
  "query": {
    "type": "terminal",
    "service": "sequence",
    "parameters": {
      "sequence_type": "protein",
      "value": "MNGTEGPNFYVPFSNKTGVVRSPFEAPQYYLAEPWQFSMLAAYMFLLIMLGFPINFLTLYVTVQHKKLRTPLNYILLNLAVADLFMVFGGFTTTLYTSLHGYFVFGPTGCNLEGFFATLGGEIALWSLVVLAIERYVVVCKPMSNFRFGENHAIMGVAFTWVMALACAAPPLVGWSRYIPEGMQCSCGIDYYTPHEETNNESFVIYMFVVHFIIPLIVIFFCYGQLVFTVKEAAAQQQESATTQKAEKEVTRMVIIMVIAFLICWLPYAGVAFYIFTHQGSDFGPIFMTIPAFFAKTSAVYNPVIYIMMNKQFRNCMVTTLCCGKNPLGDDEASTTVSKTETSQVAPA",
      "identity_cutoff": 0.3,
      "evalue_cutoff": 0.1
    }
  },
  "request_options": {
    "results_verbosity": "minimal",
    "group_by": {
      "aggregation_method": "sequence_identity",
      "similarity_cutoff": 50,
      "ranking_criteria_type": {
        "sort_by": "score",
        "direction": "asc"
      }
    },
    "group_by_return_type": "groups"
  },
  "return_type": "polymer_entity"
}
```

--------------------------------

### RCSB Search API: Suggest Service (Bash)

Source: https://context7.com/context7/search_rcsb/llms.txt

Demonstrates how to use the suggest endpoint to get real-time search suggestions for auto-complete functionality using curl. This is useful for building interactive search interfaces.

```bash
curl "https://search.rcsb.org/rcsbsearch/v2/suggest?json=%7B%22q%22%3A%22hemoglobin%22%7D"
```

--------------------------------

### RCSB PDB Search API - General Information

Source: https://search.rcsb.org/index

Information about the RCSB PDB Search API, including its base URI and how to construct search requests using GET or POST methods.

```APIDOC
## RCSB PDB Search API

### Description
The RCSB PDB Search API accepts HTTP GET or POST requests with JSON payloads to query the Protein Data Bank.

### Method
GET or POST

### Endpoint
`https://search.rcsb.org/rcsbsearch/v2/query`

### Query Parameters (for GET requests)
- **json** (string) - URL-encoded JSON string representing the search request.

### Request Body (for POST requests)
- **json** (object) - JSON object representing the search request.

### Details
- The `json` parameter for GET requests should contain the URL-encoded search request.
- The search API is designed to return only the identifiers of relevant hits and additional metadata.
- For detailed information on released date, macromolecules, organisms, resolution, modified residues, ligands etc., use the RCSB Data API: https://data.rcsb.org.

### Resources
- Reference Documentation: RCSB PDB Search API Reference
- Query Editor: RCSB PDB Search API Query Editor
- Examples: RCSB PDB Search API Examples

### Mailing List Subscription
- Subscribe via Google account or send an email to `api+subscribe@rcsb.org`.
```

--------------------------------

### RCSB Search API: Compact Query Example

Source: https://context7.com/context7/search_rcsb/llms.txt

Constructs and executes a compact search query to retrieve only entry identifiers. This is useful for retrieving a simple list of matching entries without additional metadata.

```python
import requests

query_compact = {
    "query": {
        "type": "terminal",
        "service": "text",
        "parameters": {
            "operator": "equals",
            "value": 4,
            "attribute": "rcsb_entry_info.polymer_entity_count_RNA"
        }
    },
    "request_options": {
        "results_verbosity": "compact"
    },
    "return_type": "entry"
}

response = requests.post(
    "https://search.rcsb.org/rcsbsearch/v2/query",
    json=query_compact
)
# Result set: ["7K00", "7JZ9", "7JZ8", ...]
```

--------------------------------

### Combine Search Services (text, sequence, structure, chemical) using AND

Source: https://search.rcsb.org/index

This example composes text, sequence, structure, and chemical queries using the Boolean operator AND. It retrieves structures that match all specified criteria, including co-crystal structures with a specific inhibitor and matching a given SMILES string.

```json
{
  "query": {
    "type": "group",
    "logical_operator": "and",
    "nodes": [
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "operator": "exact_match",
          "value": "Coronaviridae",
          "attribute": "rcsb_entity_source_organism.taxonomy_lineage.name"
        }
      },
      {
        "type": "terminal",
        "service": "sequence",
        "parameters": {
          "evalue_cutoff": 1,
          "identity_cutoff": 0.5,
          "sequence_type": "protein",
          "value": "SLSGFRKMAFPSGKVEGCMVQVTCGTTTLNGLWLDDTVYCPRHVICTAEDMLNPNYEDLLIRKSNHSFLVQAGNVQLRVIGHSMQNCLLRLKVDTSNPKTPKYKFVRIQPGQTFSVLACYNGSPSGVYQCAMRPNHTIKGSFLNGSCGSVGFNIDYDCVSFCYMHHMELPTGVHAGTDLEGKFYGPFVDRQTAQAAGTDTTITLNVLAWLYAAVINGDRWFLNRFTTTLNDFNLVAMKYNYEPLTQDHVDILGPLSAQTGIAVLDMCAALKELLQNGMNGRTILGSTILEDEFTPFDVVRQCSGVTEG"
        }
      },
      {
        "type": "terminal",
        "service": "structure",
        "parameters": {
          "value": {
            "entry_id": "6LU7",
            "assembly_id": "1"
          },
          "operator": "relaxed_shape_match"
        }
      },
      {
        "type": "terminal",
        "service": "chemical",
        "parameters": {
          "value": "CC(C)C[C@H](NC(=O)OCC1CCC(F)(F)CC1)C(=O)N[C@@H](C[C@@H]2CCNC2=O)[C@@H](O)[S](O)(=O)=O",
          "type": "descriptor",
          "descriptor_type": "SMILES",
          "match_type": "graph-relaxed-stereo"
        }
      }
    ]
  },
  "return_type": "entry"
}
```

--------------------------------

### Get Sequence Cluster Statistics

Source: https://search.rcsb.org/index

This example retrieves the count of distinct protein sequences in the PDB archive. It utilizes facets with filters based on aggregation method and similarity cutoff to define the sequence clusters.

```json
{
  "request_options": {
    "facets": [
      {
        "filter": {
          "type": "group",
          "logical_operator": "and",
          "nodes": [
            {
              "type": "terminal",
              "service": "text",
              "parameters": {
                "operator": "exact_match",
                "attribute": "rcsb_polymer_entity_group_membership.aggregation_method",
                "value": "sequence_identity"
              }
            },
            {
              "type": "terminal",
              "service": "text",
              "parameters": {
                "operator": "equals",
                "attribute": "rcsb_polymer_entity_group_membership.similarity_cutoff",
                "value": 100
              }
            }
          ]
        },
        "facets": [
          {
            "name": "Distinct Protein Sequence Count",
            "aggregation_type": "cardinality",
            "attribute": "rcsb_polymer_entity_group_membership.group_id"
          }
        ]
      }
    ],
    "paginate": {
      "start": 0,
      "rows": 0
    }
  },
  "return_type": "polymer_entity"
}
```

--------------------------------

### Get Only Facet Counts for PDB Structures by Method (JSON)

Source: https://search.rcsb.org/index

This example shows how to retrieve only the facet counts for PDB structures broken down by experimental method, for structures released after a specific date. It achieves this by setting 'rows' to 0 in the pagination context.

```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "operator": "greater",
      "value": "2019-08-20",
      "attribute": "rcsb_accession_info.initial_release_date"
    }
  },
  "request_options": {
    "paginate": {
      "rows": 0
    },
    "facets": [
      {
        "name": "Methods",
        "aggregation_type": "terms",
        "attribute": "exptl.method"
      }
    ]
  },
  "return_type": "entry"
}
```

--------------------------------

### RCSB PDB Search API Query Example

Source: https://search.rcsb.org/query-editor_json=%7B%22request_options%22%3A%7B%22paginate%22%3A%7B%22rows%22%3A0%7D%2C%22facet_d44df0_.2%2C%22to%22%3A2.4%7D%2C%7B%22from%22%3A4

This JSON object demonstrates a sample query structure for the RCSB PDB Search API. It includes configurations for pagination and faceted search, specifically for 'Resolution Combined' attribute with defined ranges. The 'return_type' is set to 'entry'.

```json
{
"request_options": {
"paginate": {
"rows": 0
},
"facets": [
{
"name": "Resolution Combined",
"aggregation_type": "range",
"attribute": "rcsb_entry_info.resolution_combined",
"ranges": [
{
"to": 2
},
{
"from": 2,
"to": 2.2
},
{
"from": 2.2,
"to": 2.4
},
{
"from": 4.6
}
]
}
],
"return_type": "entry"
}
}
```

--------------------------------

### Released Data Search API (GET)

Source: https://search.rcsb.org/openapi

Perform GET requests for textual and scientific searches against current RCSB PDB entries.

```APIDOC
## GET /rcsbsearch/v2/query

### Description
Released data search API endpoint allows you to perform GET requests with textual and scientific searches against current RCSB PDB entries.

### Method
GET

### Endpoint
/rcsbsearch/v2/query

### Parameters
#### Query Parameters
- **json** (string) - Required - Search query. Must be URL-encoded.

### Request Example
```json
{
  "query": "?json=<URL-encoded-search-query>"
}
```

### Response
#### Success Response (200)
- **application/json** - Contains search results.

#### Response Example
```json
{
  "example": "response body schema/search/response/json-schema-rcsb_search_results.json"
}
```

#### Error Responses
- **400**: Bad Request. Malformed request or invalid query syntax.
- **404**: Not Found. The requested resource was not found.
- **415**: Unsupported Media Type. Payload format is unsupported.
- **501**: Not Implemented. Server does not support the required functionality.
- **408**: Request Timeout. Server did not receive complete results within the expected time.
- **500**: Internal Server Error. Unexpected error on the server.
- **204**: No Content. Successfully processed the request, but no results were returned.
- **503**: Service Unavailable. Server is temporarily unable to handle the request.
```

--------------------------------

### Combining Search Services

Source: https://search.rcsb.org/index

This endpoint demonstrates how to combine text, sequence, structure, and chemical queries using a Boolean AND operator. It retrieves structures that match all specified criteria, including co-crystal structures with desired inhibitors and sequences.

```APIDOC
## Combining Search Services

### Description
This example shows how to compose `text`, `sequence`, `structure`, and `chemical` queries employing the Boolean operator AND. The search yields structures (entries) matching all criteria, including co-crystal structures with the desired bound inhibitor, matching the SMILES string for a small-molecule inhibitor designated 7J (QYS).

### Method
POST

### Endpoint
/websites/search_rcsb

### Parameters
#### Request Body
- **query** (object) - Required - The search query object.
  - **type** (string) - Required - Type of the query node (e.g., "group", "terminal").
  - **logical_operator** (string) - Optional - Boolean operator for "group" type (e.g., "and", "or").
  - **nodes** (array) - Optional - Array of query nodes for "group" type.
    - **type** (string) - Required - Type of the query node (e.g., "terminal").
    - **service** (string) - Required - The search service to use (e.g., "text", "sequence", "structure", "chemical").
    - **parameters** (object) - Required - Parameters specific to the search service.
      - **operator** (string) - Required - The matching operator (e.g., "exact_match", "relaxed_shape_match").
      - **value** (string or object) - Required - The search value.
      - **attribute** (string) - Optional - The attribute to search within (for "text" service).
      - **evalue_cutoff** (number) - Optional - E-value cutoff for "sequence" service.
      - **identity_cutoff** (number) - Optional - Identity cutoff for "sequence" service.
      - **sequence_type** (string) - Optional - Type of sequence (e.g., "protein") for "sequence" service.
      - **entry_id** (string) - Optional - Entry ID for "structure" service.
      - **assembly_id** (string) - Optional - Assembly ID for "structure" service.
      - **descriptor_type** (string) - Optional - Descriptor type for "chemical" service (e.g., "SMILES").
      - **match_type** (string) - Optional - Match type for "chemical" service.
- **return_type** (string) - Required - The type of results to return (e.g., "entry").

### Request Example
```json
{
  "query": {
    "type": "group",
    "logical_operator": "and",
    "nodes": [
      {
        "type": "terminal",
        "service": "text",
        "parameters": {
          "operator": "exact_match",
          "value": "Coronaviridae",
          "attribute": "rcsb_entity_source_organism.taxonomy_lineage.name"
        }
      },
      {
        "type": "terminal",
        "service": "sequence",
        "parameters": {
          "evalue_cutoff": 1,
          "identity_cutoff": 0.5,
          "sequence_type": "protein",
          "value": "SLSGFRKMAFPSGKVEGCMVQVTCGTTTLNGLWLDDTVYCPRHVICTAEDMLNPNYEDLLIRKSNHSFLVQAGNVQLRVIGHSMQNCLLRLKVDTSNPKTPKYKFVRIQPGQTFSVLACYNGSPSGVYQCAMRPNHTIKGSFLNGSCGSVGFNIDYDCVSFCYMHHMELPTGVHAGTDLEGKFYGPFVDRQTAQAAGTDTTITLNVLAWLYAAVINGDRWFLNRFTTTLNDFNLVAMKYNYEPLTQDHVDILGPLSAQTGIAVLDMCAALKELLQNGMNGRTILGSTILEDEFTPFDVVRQCSGVTEG"
        }
      },
      {
        "type": "terminal",
        "service": "structure",
        "parameters": {
          "value": {
            "entry_id": "6LU7",
            "assembly_id": "1"
          },
          "operator": "relaxed_shape_match"
        }
      },
      {
        "type": "terminal",
        "service": "chemical",
        "parameters": {
          "value": "CC(C)C[C@H](NC(=O)OCC1CCC(F)(F)CC1)C(=O)N[C@@H](C[C@@H]2CCNC2=O)[C@@H](O)[S](O)(=O)=O",
          "type": "descriptor",
          "descriptor_type": "SMILES",
          "match_type": "graph-relaxed-stereo"
        }
      }
    ]
  },
  "return_type": "entry"
}
```

### Response
#### Success Response (200)
- **results** (array) - List of matching entries.
- **total_count** (integer) - The total number of matching entries.

#### Response Example
```json
{
  "result_set": [
    {
      "entry_id": "7C9Y"
    }
  ],
  "total_count": 1
}
```
```

--------------------------------

### GET /rcsbsearch/v2/query/unreleased

Source: https://search.rcsb.org/redoc/index

This endpoint allows you to perform GET requests with textual searches against RCSB PDB unreleased entries.

```APIDOC
## GET /rcsbsearch/v2/query/unreleased

### Description
This endpoint allows you to perform GET requests with textual searches against RCSB PDB unreleased entries.

### Method
GET

### Endpoint
/rcsbsearch/v2/query/unreleased

### Parameters
#### Query Parameters
- **query** (object) - Required - URL-encoded JSON object representing the search query. (See POST request body for structure).

### Request Example
```
GET https://search.rcsb.org/rcsbsearch/v2/query/unreleased?query=%7B%22query%22%3A%20%7B%22type%22%3A%20%22group%22%2C%20%22nodes%22%3A%20%5B%7B%22type%22%3A%20%22terminal%22%2C%20%22service%22%3A%20%22full_text%22%2C%20%22parameters%22%3A%20%7B%22value%22%3A%20%22%2A%22%7D%7D%5D%7D%7D
```

### Response
#### Success Response (200)
- **query_id** (string) - Identifier for the query.
- **result_type** (string) - The type of the results.
- **total_count** (integer) - Total number of matching entries.
- **group_by_count** (integer) - Number of entries grouped by.
- **ungrouped_count** (integer) - Number of ungrouped entries.
- **explain_metadata** (object) - Metadata about the query execution time.
- **result_set** (array) - An array of result identifiers.
- **facets** (array) - An array of facet objects.
- **group_by** (object) - Grouping information if requested.
- **group_set** (array) - An array of group identifiers.

#### Response Example
```json
{
  "query_id": "string",
  "result_type": "entry",
  "total_count": 1,
  "group_by_count": 1,
  "ungrouped_count": 1,
  "explain_metadata": {
    "total_timing": 0,
    "facet_timing": 0,
    "sort_timing": 0,
    "grouping_timing": 0,
    "terminal_node_timings": {}
  },
  "result_set": [
    "string"
  ],
  "facets": [
    {
      "name": "string",
      "buckets": [
        {
          "label": "string",
          "population": 0,
          "facets": []
        }
      ]
    }
  ],
  "group_by": {
    "aggregation_method": "matching_deposit_group_id",
    "ranking_criteria_type": {
      "sort_by": "score",
      "filter": {
        "type": "group",
        "logical_operator": "or",
        "nodes": [
          {
            "type": "terminal",
            "parameters": {
              "value": "string",
              "attribute": "string",
              "negation": false,
              "operator": "equals",
              "case_sensitive": false
            }
          }
        ]
      },
      "direction": "asc"
    }
  },
  "group_set": [
    "string"
  ]
}
```

### Error Handling
- **204** No Content: The server successfully processed the request and did not return any results.
- **400** Bad Request: The server cannot process the request due to malformed request or invalid query syntax.
- **404** Not Found: The requested resource was not found.
- **408** Request Timeout: The server did not receive complete results within the time that it was prepared to wait.
- **415** Unsupported Media Type: The server refuses to accept the request because the payload format is in an unsupported format.
- **500** Internal Server Error: The server encountered an unexpected error.
- **501** Not Implemented: The server does not support the functionality required to fulfill the request.
- **503** Service Unavailable: The server is currently unable to handle the request due to temporary overloading.
```

--------------------------------

### GET /rcsbsearch/v2/query

Source: https://search.rcsb.org/redoc/index

Allows you to perform GET requests with textual and scientific searches against current RCSB PDB entries.

```APIDOC
## GET /rcsbsearch/v2/query

### Description
Allows you to perform GET requests with textual and scientific searches against current RCSB PDB entries.

### Method
GET

### Endpoint
https://search.rcsb.org/rcsbsearch/v2/query

### Parameters
#### Query Parameters
- **query** (object) - Required - Search query. Must be URL-encoded.

### Request Example
```json
{
  "query": "(படிப்பு='3D-DIP'")"
}
```

### Response
#### Success Response (200)
- **query_id** (string) - Unique identifier for the query.
- **result_type** (string) - The type of results returned (e.g., "entry").
- **total_count** (integer) - Total number of results found.
- **group_by_count** (integer) - Number of results grouped.
- **ungrouped_count** (integer) - Number of ungrouped results.
- **explain_metadata** (object) - Metadata about the query execution time.
- **result_set** (array) - An array of result identifiers.
- **facets** (array) - Facet information for the results.
- **group_by** (object) - Grouping information for the results.
- **group_set** (array) - An array of grouped result identifiers.

#### Response Example
```json
{
  "query_id": "64b42e4712345678",
  "result_type": "entry",
  "total_count": 100,
  "group_by_count": 50,
  "ungrouped_count": 50,
  "explain_metadata": {
    "total_timing": 150,
    "facet_timing": 20,
    "sort_timing": 10,
    "grouping_timing": 30,
    "terminal_node_timings": {}
  },
  "result_set": [
    "1ABC",
    "2DEF",
    "3GHI"
  ],
  "facets": [
    {
      "name": "rcsb_accession_info.initial_release_date",
      "buckets": [
        {
          "label": "2023",
          "population": 75,
          "facets": []
        }
      ]
    }
  ],
  "group_by": {
    "aggregation_method": "matching_deposit_group_id",
    "ranking_criteria_type": {
      "sort_by": "score",
      "filter": {
        "type": "group",
        "logical_operator": "or",
        "nodes": [
          {
            "type": "terminal",
            "parameters": {
              "value": "100",
              "attribute": "rcsb_entry_container_identifiers.entry_id",
              "negation": false,
              "operator": "equals",
              "case_sensitive": false
            }
          }
        ]
      },
      "direction": "asc"
    }
  },
  "group_set": [
    "GROUP_1",
    "GROUP_2"
  ]
}
```
```

--------------------------------

### RCSB PDB Search API Query Editor

Source: https://search.rcsb.org/query-editor_json=%7B%22query%22%3A%7B%22type%22%3A%22terminal%22%2C%22service%22%3A%22text%22%2_962137_C%22request_options%22%3A%7B%22return_all_hits%22%3Atrue%7D%2C%22return_type%22%3A%22entry%22%7D

An example of a query to the RCSB PDB Search API to find entries released within the last week.

```APIDOC
## POST /search

### Description
This endpoint allows you to perform complex searches against the RCSB PDB database. You can specify search criteria using a structured JSON query.

### Method
POST

### Endpoint
/search

### Parameters
#### Request Body
- **query** (object) - Required - The search query object defining the search criteria.
- **request_options** (object) - Optional - Options for the search request, such as returning all hits.
- **return_type** (string) - Required - The type of data to return (e.g., 'entry').

### Request Example
```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "attribute": "rcsb_accession_info.initial_release_date",
      "operator": "greater",
      "value": "now-1w"
    }
  },
  "request_options": {
    "return_all_hits": true
  },
  "return_type": "entry"
}
```

### Response
#### Success Response (200)
- **result** (array) - A list of search results matching the query.

#### Response Example
```json
{
  "result": [
    {
      "entry": {
        "rcsb_id": "1ABC"
      }
    }
    // ... more results
  ]
}
```
```

--------------------------------

### GET /rcsbsearch/v2/query/unreleased

Source: https://search.rcsb.org/openapi

This endpoint allows you to perform GET requests with textual searches against RCSB PDB unreleased entries. The search query must be URL-encoded.

```APIDOC
## GET /rcsbsearch/v2/query/unreleased

### Description
Performs textual searches against RCSB PDB unreleased entries.

### Method
GET

### Endpoint
/rcsbsearch/v2/query/unreleased

### Parameters
#### Query Parameters
- **json** (string) - Required - Search query. Must be URL-encoded.

### Request Example
```
GET /rcsbsearch/v2/query/unreleased?json=%7B%22query%22%3A%20%7B%22type%22%3A%20%22group%22%2C%20%22nodes%22%3A%20%5B%7B%22type%22%3A%20%22terminal%22%2C%20%22service%22%3A%20%22text%22%2C%20%22parameters%22%3A%20%5B%7B%22type%22%3A%20%22value%22%2C%20%22name%22%3A%20%22value%22%2C%20%22value%22%3A%20%221bga%22%7D%5D%7D%5D%7D%7D
```

### Response
#### Success Response (200)
- **results** (array) - Contains the search results matching the query.

#### Response Example
```json
{
  "query_id": "12345",
  "result_type": "unreleased_entry",
  "total_count": 5,
  "entries": [
    {
      "entry_id": "UR123",
      "status": "under_review",
      "title": "Structure of protein X"
    }
  ]
}
```

#### Error Responses
- **400 Bad Request**: Invalid query syntax.
- **404 Not Found**: The requested resource was not found.
- **415 Unsupported Media Type**: The server refuses to accept the request because the payload format is in an unsupported format.
- **501 Not Implemented**: The server does not support the functionality required to fulfill the request.
- **408 Request Timeout**: The server did not receive complete results within the time that it was prepared to wait.
- **500 Internal Server Error**: The server encountered an unexpected error.
- **204 No Content**: No results were found.
- **503 Service Unavailable**: The server is currently unable to handle the request due to temporary overloading.
```

--------------------------------

### RCSB PDB Search API: Attribute-Based Text Search Examples

Source: https://context7.com/context7/search_rcsb/llms.txt

Illustrates attribute-based text searches using the RCSB PDB Search API, allowing for precise queries against specific metadata fields like experimental method and release dates.

```python
import requests

# Search by experimental method
query = {
    "query": {
        "type": "terminal",
        "service": "text",
        "parameters": {
            "attribute": "exptl.method",
            "operator": "exact_match",
            "value": "ELECTRON MICROSCOPY"
        }
    },
    "return_type": "entry"
}

# Date range search
query_date_range = {
    "query": {
        "type": "terminal",
        "service": "text",
        "parameters": {
            "attribute": "rcsb_accession_info.initial_release_date",
            "operator": "range",
            "value": {
                "from": "2019-01-01",
                "to": "2019-06-30"
            }
        }
    },
    "return_type": "entry"
}

response = requests.post(
    "https://search.rcsb.org/rcsbsearch/v2/query",
    json=query_date_range
)
```

--------------------------------

### RCSB PDB Search API: Full-Text Search Examples

Source: https://context7.com/context7/search_rcsb/llms.txt

Demonstrates how to perform full-text searches across all textual annotations in the PDB archive using the RCSB PDB Search API. Supports basic searches with AND operators and complex boolean precedence.

```python
import requests

# Basic full-text search with AND operators
query = {
    "query": {
        "type": "terminal",
        "service": "full_text",
        "parameters": {
            "value": "interferon + response + factor"
        }
    },
    "return_type": "entry"
}

response = requests.post(
    "https://search.rcsb.org/rcsbsearch/v2/query",
    json=query
)
results = response.json()

# Boolean precedence example: isopeptide AND (collagen OR fibrinogen)
query_complex = {
    "query": {
        "type": "terminal",
        "service": "full_text",
        "parameters": {
            "value": "isopeptide + ( collagen | fibrinogen )"
        }
    },
    "return_type": "entry"
}

response = requests.post(
    "https://search.rcsb.org/rcsbsearch/v2/query",
    json=query_complex
)
```

--------------------------------

### Search Query Endpoint (GET)

Source: https://context7.com/context7/search_rcsb/llms.txt

Perform searches using URL-encoded JSON queries in the query parameter, useful for simple requests and browser-based testing. This endpoint accepts GET requests.

```APIDOC
## GET /rcsbsearch/v2/query

### Description
Perform searches using URL-encoded JSON queries in the query parameter, useful for simple requests and browser-based testing.

### Method
GET

### Endpoint
https://search.rcsb.org/rcsbsearch/v2/query

### Parameters
#### Query Parameters
- **json** (string) - Required - URL-encoded JSON string representing the search query.

### Request Example
```bash
# Basic search for all entries (URL-encoded JSON)
curl "https://search.rcsb.org/rcsbsearch/v2/query?json=%7B%22query%22%3A%7B%22type%22%3A%22terminal%22%2C%22service%22%3A%22text%22%7D%2C%22return_type%22%3A%22entry%22%7D"
```

### Response
#### Success Response (200)
- **query_id** (string) - Unique identifier for the query.
- **result_type** (string) - The type of results returned.
- **total_count** (integer) - The total number of matching entries found.
- **result_set** (array) - An array of matching entries, each with an identifier and score.

#### Response Example
```json
{
  "query_id": "...",
  "result_type": "entry",
  "total_count": 23156,
  "result_set": [
    {"identifier": "7K00", "score": 1.0},
    {"identifier": "7JZ9", "score": 1.0},
    {"identifier": "7JZ8", "score": 1.0}
  ]
}
```
```

--------------------------------

### Range Operator Example

Source: https://search.rcsb.org/index

Demonstrates the usage of the 'range' operator to filter results within a specified date range. This operator requires a JSON object with 'from' and 'to' values, and optionally 'include_lower' and 'include_upper' booleans to define the inclusivity of the bounds. The example searches for entries released between '2019-01-01' and '2019-06-30'.

```json
{
  "query": {
    "type": "terminal",
    "service": "text",
    "parameters": {
      "attribute": "rcsb_accession_info.initial_release_date",
      "operator": "range",
      "value": {
        "from": "2019-01-01",
        "to": "2019-06-30"
      }
    }
  },
  "return_type": "entry"
}
```
Tokens:
Raw