For clean Markdown of any page, append .md to the page URL. For a complete documentation index, see https://api-doc-new.gideononline.com/gideon-api-1-0/diseases/llms.txt. For full documentation content, see https://api-doc-new.gideononline.com/gideon-api-1-0/diseases/llms-full.txt.

# /diseases/filter

GET https://api.gideononline.com/diseases/filter

This endpoint returns list of all diseases matching filters. This is a valuable tool for the diagnostician. It can be used to create disease profiles and to generate reports on the status of diseases in any country.

The user employs the filter API to generate a list of diseases that fit an epidemiological profile. The following filters are available:

- Agent – Classification (e.g., virus, parasite) and taxonomic designation.
- Vector – An arthropod or other living carrier which transports an infectious agent from an infected organism or reservoir to a susceptible individual or immediate surroundings.
- Vehicle – The mode of transmission for an infectious agent. This generally implies a passive and inanimate (i.e., non-vector) mode.
- Reservoir – Any animal, arthropod, plant, soil or substance in which an infectious agent normally lives and multiplies, on which it depends primarily for survival, and where it reproduces itself in such a manner that it can be transmitted to a susceptible host.
- Country – In general, this list of country names corresponds to accepted geographical and political designations. When Country filter is used, it will only retrieve diseases that are endemic to the country. 

Reference: https://api-doc-new.gideononline.com/gideon-api-1-0/diseases/diseases-filter

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /diseases/filter:
    get:
      operationId: diseases-filter
      summary: /diseases/filter
      description: >-
        This endpoint returns list of all diseases matching filters. This is a
        valuable tool for the diagnostician. It can be used to create disease
        profiles and to generate reports on the status of diseases in any
        country.


        The user employs the filter API to generate a list of diseases that fit
        an epidemiological profile. The following filters are available:


        - Agent – Classification (e.g., virus, parasite) and taxonomic
        designation.

        - Vector – An arthropod or other living carrier which transports an
        infectious agent from an infected organism or reservoir to a susceptible
        individual or immediate surroundings.

        - Vehicle – The mode of transmission for an infectious agent. This
        generally implies a passive and inanimate (i.e., non-vector) mode.

        - Reservoir – Any animal, arthropod, plant, soil or substance in which
        an infectious agent normally lives and multiplies, on which it depends
        primarily for survival, and where it reproduces itself in such a manner
        that it can be transmitted to a susceptible host.

        - Country – In general, this list of country names corresponds to
        accepted geographical and political designations. When Country filter is
        used, it will only retrieve diseases that are endemic to the country. 
      tags:
        - subpackage_diseases
      parameters:
        - name: agent
          in: query
          description: >-
            agent code. Get list of agents by calling
            /diseases/fingerprint/agents
          required: false
          schema:
            type: string
        - name: vector
          in: query
          description: >
            vector code. Get list of vectors by calling
            /diseases/fingerprint/vectors
          required: false
          schema:
            type: string
        - name: vehicle
          in: query
          description: >-
            vehicle code. Get list of vehicles by calling
            /diseases/fingerprint/vehicles
          required: false
          schema:
            type: string
        - name: reservoir
          in: query
          description: >-
            reservoir code. Get list of reservoirs by calling
            /diseases/fingerprint/reservoirs
          required: false
          schema:
            type: string
        - name: country
          in: query
          description: >-
            country code. Get list of countries by calling
            /diseases/fingerprint/countries
          required: false
          schema:
            type: string
        - name: return
          in: query
          description: simple | detailed
          required: false
          schema:
            type: string
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Diseases_/diseases/filter_Response_200'
servers:
  - url: https://api.gideononline.com
  - url: https://api-test.gideononline.com
components:
  schemas:
    DiseasesFilterGetResponsesContentApplicationJsonSchemaDataItems:
      type: object
      properties:
        disease:
          type: string
        disease_code:
          type: integer
      required:
        - disease
        - disease_code
      title: DiseasesFilterGetResponsesContentApplicationJsonSchemaDataItems
    Diseases_/diseases/filter_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: >-
              #/components/schemas/DiseasesFilterGetResponsesContentApplicationJsonSchemaDataItems
      required:
        - data
      title: Diseases_/diseases/filter_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: Authorization

```

## SDK Code Examples

```python Diseases_/diseases/filter_example
import requests

url = "https://api.gideononline.com/diseases/filter"

querystring = {"agent":"Optional","vector":"Optional","vehicle":"Optional","reservoir":"Optional","country":"Optional","return":"Optional"}

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Diseases_/diseases/filter_example
const url = 'https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

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

```go Diseases_/diseases/filter_example
package main

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

func main() {

	url := "https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional"

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

	req.Header.Add("Authorization", "<apiKey>")

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

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

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

}
```

```ruby Diseases_/diseases/filter_example
require 'uri'
require 'net/http'

url = URI("https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional")

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

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

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

```java Diseases_/diseases/filter_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp Diseases_/diseases/filter_example
using RestSharp;

var client = new RestClient("https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Diseases_/diseases/filter_example
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.gideononline.com/diseases/filter?agent=Optional&vector=Optional&vehicle=Optional&reservoir=Optional&country=Optional&return=Optional")! 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()
```