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/outbreaks

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

Returns a list of disease outbreaks that were active during the specified year. An outbreak is considered active if either its first reported year or last reported year falls within the provided year.

- **`outbreak_start`** _(deprecated)_ – Replaced by `outbreak_first_reported`. Do not use.
- **`outbreak_end`** _(deprecated)_ – Replaced by `outbreak_last_reported`. Do not use.
    

The `type` field in the outbreak response indicates the nature of the reported disease occurrence. It can have one or two comma-separated values:

| Value | Description |
| --- | --- |
| `outbreak` | A confirmed outbreak involving multiple cases linked by time and location. |
| `sporadic` | A single or isolated case not linked to other known cases. |
| `travelcase` | The case was imported from another country or region, typically through travel. |
| `outbreak,travelcases` | A cluster of travel-related cases that are considered part of an outbreak. |
| `sporadic,travelcase` | A single travel-related case that is not part of a known outbreak. |

> 

**Note:** Values may appear in combination (e.g., `outbreak,travelcases`) to indicate both the type of event and whether the case(s) were travel-related.

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

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /diseases/outbreaks:
    get:
      operationId: diseases-outbreaks
      summary: /diseases/outbreaks
      description: >-
        Returns a list of disease outbreaks that were active during the
        specified year. An outbreak is considered active if either its first
        reported year or last reported year falls within the provided year.


        - **`outbreak_start`** _(deprecated)_ – Replaced by
        `outbreak_first_reported`. Do not use.

        - **`outbreak_end`** _(deprecated)_ – Replaced by
        `outbreak_last_reported`. Do not use.
            

        The `type` field in the outbreak response indicates the nature of the
        reported disease occurrence. It can have one or two comma-separated
        values:


        | Value | Description |

        | --- | --- |

        | `outbreak` | A confirmed outbreak involving multiple cases linked by
        time and location. |

        | `sporadic` | A single or isolated case not linked to other known
        cases. |

        | `travelcase` | The case was imported from another country or region,
        typically through travel. |

        | `outbreak,travelcases` | A cluster of travel-related cases that are
        considered part of an outbreak. |

        | `sporadic,travelcase` | A single travel-related case that is not part
        of a known outbreak. |


        > 


        **Note:** Values may appear in combination (e.g.,
        `outbreak,travelcases`) to indicate both the type of event and whether
        the case(s) were travel-related.
      tags:
        - subpackage_diseases
      parameters:
        - name: year
          in: query
          required: false
          schema:
            type: integer
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Diseases_/diseases/outbreaks_Response_200'
servers:
  - url: https://api.gideononline.com
  - url: https://api-test.gideononline.com
components:
  schemas:
    DiseasesOutbreaksGetResponsesContentApplicationJsonSchemaDataItems:
      type: object
      properties:
        id:
          type: string
        city:
          description: Any type
        type:
          type: string
        cases:
          type: integer
        state:
          description: Any type
        deaths:
          description: Any type
        region:
          description: Any type
        country:
          type: string
        disease:
          type: string
        hash_id:
          type: string
          format: uuid
        latitude:
          description: Any type
        longitude:
          description: Any type
        update_date:
          type: string
        country_code:
          type: string
        disease_code:
          type: integer
        outbreak_end:
          description: Any type
        outbreak_start:
          type: integer
        publication_year:
          description: Any type
        update_date_epoch:
          type: integer
        outbreak_last_reported:
          type: integer
        outbreak_first_reported:
          type: integer
      required:
        - id
        - type
        - cases
        - country
        - disease
        - hash_id
        - update_date
        - country_code
        - disease_code
        - outbreak_start
        - update_date_epoch
        - outbreak_last_reported
        - outbreak_first_reported
      title: DiseasesOutbreaksGetResponsesContentApplicationJsonSchemaDataItems
    Diseases_/diseases/outbreaks_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: >-
              #/components/schemas/DiseasesOutbreaksGetResponsesContentApplicationJsonSchemaDataItems
      required:
        - data
      title: Diseases_/diseases/outbreaks_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: Authorization

```

## SDK Code Examples

```python Diseases_/diseases/outbreaks_example
import requests

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

querystring = {"year":"2025"}

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

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

print(response.json())
```

```javascript Diseases_/diseases/outbreaks_example
const url = 'https://api.gideononline.com/diseases/outbreaks?year=2025';
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/outbreaks_example
package main

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

func main() {

	url := "https://api.gideononline.com/diseases/outbreaks?year=2025"

	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/outbreaks_example
require 'uri'
require 'net/http'

url = URI("https://api.gideononline.com/diseases/outbreaks?year=2025")

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/outbreaks_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.gideononline.com/diseases/outbreaks?year=2025")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.gideononline.com/diseases/outbreaks?year=2025', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

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

var client = new RestClient("https://api.gideononline.com/diseases/outbreaks?year=2025");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Diseases_/diseases/outbreaks_example
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.gideononline.com/diseases/outbreaks?year=2025")! 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()
```