Is KenyaAPI free to use?

Yes. KenyaAPI is completely free and open with no authentication or API key required.

Does KenyaAPI require an API key?

No. All endpoints are publicly accessible without authentication. Rate limiting applies at 100 requests per minute per IP.

What data does KenyaAPI provide?

KenyaAPI provides data on Kenya's 47 counties, 290 constituencies, 1,263 wards, public holidays, population statistics, exchange rates, educational institutions, government ministries, national parks, and presidents.

KenyaAPI Documentation

Free, open REST API for Kenyan public data. No API key required.

Free Forever

No Auth Required

Global Search

Search across all KenyaAPI resources in a single request. Returns grouped results from counties, constituencies, holidays, institutions, ministries, and exchange rates.

⌕

Type at least 2 characters to search

Base URL

All endpoints below are relative to this base URL.

https://kenya-api.netlify.app/api/v1

Authentication

No authentication required. All endpoints are publicly accessible.

Rate limiting is enforced for availability: 100 requests per minute per IP.

Response Format

All successful responses use a consistent JSON shape.

{
  "success": true,
  "count": 47,
  "data": [ ... ]
}

{
  "success": false,
  "error": "County with ID 99 not found",
  "statusCode": 404
}

Error Codes

Common HTTP response codes and their typical causes.

Code	Meaning	Common Cause	Example
200	OK	Successful request	GET /counties
400	Bad Request	Invalid query or missing path param	GET /holidays?year=abc
404	Not Found	Resource ID does not exist	GET /counties/99
429	Too Many Requests	Rate limit exceeded	100 requests per minute
500	Server Error	Unexpected service failure	Internal API error

Search

Global search endpoint. Query across all six resources simultaneously or narrow by type.

GET

/search

Search across all KenyaAPI resources in a single request — counties, constituencies, holidays, institutions, ministries, and exchange rates. Use ?type= to narrow to a single resource.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars)
type	string	query	no	Narrow to one resource: counties, constituencies, holidays, institutions, ministries, exchange_rates

curl -X GET "https://kenya-api.netlify.app/api/v1/search?q=nairobi" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/search?q=nairobi", {
  method: "GET",
  headers: { "Accept": "application/json" }
});
const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/search?q=nairobi"
headers = {"Accept": "application/json"}

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

<?php
$url = "https://kenya-api.netlify.app/api/v1/search?q=nairobi";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Accept: application/json"]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/search?q=nairobi"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/search?q=nairobi")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"
response = http.request(request)
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/search?q=nairobi"))
      .header("Accept", "application/json")
      .GET()
      .build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "nairobi",
  "type": "all",
  "total_results": 24,
  "results": {
    "counties": {
      "count": 1,
      "endpoint": "/api/v1/counties",
      "data": [ { "id": 47, "name": "Nairobi" } ]
    },
    "constituencies": {
      "count": 17,
      "endpoint": "/api/v1/constituencies",
      "data": [ "..." ]
    }
  }
}

{
  "success": true,
  "query": "nairobi",
  "type": "all",
  "total_results": 24,
  "results": { ... }
}

Counties

Retrieve county-level data for all 47 Kenyan counties.

County flag images are served directly from Wikimedia Commons (upload.wikimedia.org) under Creative Commons licences. They are referenced by URL — no images are stored in this API.

GET

/counties

Returns the full list of counties. Supports optional filtering and sorting.

Name	Type	In	Required	Description
region	string	query	no	Filter counties by region, e.g. Coast
sort	string	query	no	Sort by area or population: area_asc, area_desc, population_asc, population_desc
governor_party	string	query	no	Filter by governor's party, e.g. UDA, ODM, Wiper, Independent
q	string	query	no	Full-text search across county name and description, e.g. q=coast or q=lake

curl -X GET "https://kenya-api.netlify.app/api/v1/counties" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/counties", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/counties"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/counties";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/counties"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/counties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/counties"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 47,
  "data": [
    {
      "id": 1,
      "code": "001",
      "name": "Mombasa",
      "headquarters": "Mombasa City",
      "region": "Coast",
      "area_km2": 212.5,
      "population": 1208333,
      "governor": "Abdullswamad Nassir",
      "governor_party": "ODM",
      "governor_since": 2022,
      "flag_url": "https://upload.wikimedia.org/wikipedia/commons/a/a6/Flag_of_Mombasa_County.svg",
      "description": "A coastal county along the Indian Ocean in southeastern Kenya, known for tourism, luxurious beach hotels, and the historic Mombasa Old Town."
    }
  ]
}

{
  "success": true,
  "count": 47,
  "data": [
    { "id": 1, "name": "Mombasa", "governor": "Abdullswamad Nassir", "flag_url": "https://upload.wikimedia.org/...", "description": "A coastal county..." }
  ]
}

GET

/counties/:id

Returns data for a single county by ID. Includes all fields from the county record — area, region, population, and governor details.

Name	Type	In	Required	Description
id	integer	path	yes	County ID from 1 to 47

curl -X GET "https://kenya-api.netlify.app/api/v1/counties/47" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/counties/47", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/counties/47"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/counties/47";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/counties/47"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/counties/47")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/counties/47"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 47,
    "code": "047",
    "name": "Nairobi",
    "headquarters": "Nairobi City",
    "region": "Nairobi",
    "area_km2": 694.9,
    "population": 4397073,
    "governor": "Johnson Sakaja",
    "governor_party": "UDA",
    "governor_since": 2022,
    "flag_url": "https://upload.wikimedia.org/wikipedia/commons/5/5e/Flag_of_Nairobi_County.svg",
    "description": "Kenya's capital and largest city, Nairobi is a major global metropolis, the economic hub of East Africa, home to the United Nations Environment Programme (UNEP), Nairobi National Park, and a fast-growing tech startup ecosystem."
  }
}

{
  "success": true,
  "data": {
    "id": 47, "name": "Nairobi",
    "governor": "Johnson Sakaja", "governor_party": "UDA",
    "flag_url": "https://upload.wikimedia.org/wikipedia/commons/5/5e/Flag_of_Nairobi_County.svg",
    "description": "Kenya's capital and largest city..."
  }
}

GET

/counties/governors

Returns a lightweight directory of all 47 county governors, sorted alphabetically by county name. Each record includes the governor's name, party, and year of election alongside the county's code and headquarters. Useful for building a governors index, party breakdown charts, or filtering counties by political affiliation.

curl -X GET "https://kenya-api.netlify.app/api/v1/counties/governors" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/counties/governors", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/counties/governors"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/counties/governors";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/counties/governors"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/counties/governors")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/counties/governors"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 47,
  "data": [
    {
      "id": 30,
      "code": "030",
      "name": "Baringo",
      "headquarters": "Kabarnet",
      "governor": "Benjamin Cheboi",
      "governor_party": "UDA",
      "governor_since": 2022,
      "flag_url": "https://upload.wikimedia.org/wikipedia/commons/6/6c/Flag_of_Baringo_County.svg"
    }
  ]
}

{
  "success": true,
  "count": 47,
  "data": [
    { "id": 47, "name": "Nairobi", "governor": "Johnson Sakaja", "flag_url": "https://upload.wikimedia.org/..." }
  ]
}

GET

/counties/:id/constituencies

Returns constituencies within a specific county.

Name	Type	In	Required	Description
id	integer	path	yes	County ID from 1 to 47

curl -X GET "https://kenya-api.netlify.app/api/v1/counties/47/constituencies" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/counties/47/constituencies", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/counties/47/constituencies"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/counties/47/constituencies";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/counties/47/constituencies"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/counties/47/constituencies")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/counties/47/constituencies"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": [
    { "id": 1 , "name": "Changamwe" }
  ]
}

{
  "success": true,
  "data": [
    { "id": 1 , "name": "Changamwe" }
  ]
}

Constituencies

Explore constituency-level data across Kenya.

GET

/constituencies

Returns all 290 constituencies.

curl -X GET "https://kenya-api.netlify.app/api/v1/constituencies" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/constituencies", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/constituencies"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/constituencies";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/constituencies"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/constituencies")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/constituencies"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 290,
  "data": [ ... ]
}

{
  "success": true,
  "count": 290,
  "data": [ ... ]
}

GET

/constituencies/:id

Returns a single constituency.

Name	Type	In	Required	Description
id	integer	path	yes	Constituency ID

curl -X GET "https://kenya-api.netlify.app/api/v1/constituencies/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/constituencies/1", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/constituencies/1"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/constituencies/1";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/constituencies/1"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/constituencies/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/constituencies/1"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1, "name": "Changamwe"
  }
}

{
  "success": true,
  "data": {
    "id": 1, "name": "Changamwe"
  }
}

Public Holidays

Access national holiday information for any supported year.

GET

/holidays

Returns all public holidays. Optionally filter by year.

Name	Type	In	Required	Description
year	integer	query	no	Year to filter holidays by, e.g. 2025

curl -X GET "https://kenya-api.netlify.app/api/v1/holidays?year=2025" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/holidays?year=2025", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/holidays?year=2025"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/holidays?year=2025";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/holidays?year=2025"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/holidays?year=2025")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/holidays?year=2025"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 8,
  "data": [ ... ]
}

{
  "success": true,
  "count": 9,
  "data": [ ... ]
}

GET

/holidays/:id

Returns details for a single holiday by ID.

Name	Type	In	Required	Description
id	integer	path	yes	Holiday ID

curl -X GET "https://kenya-api.netlify.app/api/v1/holidays/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/holidays/1", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/holidays/1"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/holidays/1";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/holidays/1"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/holidays/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/holidays/1"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1, "name": "New Year's Day"
  }
}

{
  "success": true,
  "data": {
    "id": 1, "name": "New Year's Day"
  }
}

Population

Retrieve national population statistics and county breakdowns.

GET

/population

Returns a summary of national population totals.

curl -X GET "https://kenya-api.netlify.app/api/v1/population" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/population", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/population"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/population";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/population"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/population")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/population"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "total_population": 53771296,
    "most_populous_county": {
      "name": "Nairobi",
      "population": 4397073
    },
    "census_year": 2019,
    "source": "Kenya National Bureau of Statistics"
  }
}

{
  "success": true,
  "data": {
    "population": 53771296,
    "female": 27358296
  }
}

GET

/population/counties

Returns population breakdown for each county.

curl -X GET "https://kenya-api.netlify.app/api/v1/population/counties" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/population/counties", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/population/counties"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/population/counties";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/population/counties"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/population/counties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/population/counties"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": [ ... ]
}

{
  "success": true,
  "data": [ ... ]
}

Exchange Rates

Returns live KES exchange rates for 25 currencies, sourced from open.er-api.com mid-market rates. Rates are refreshed hourly and cached server-side to ensure fast response times. Includes buy, mean, and sell rates with a small illustrative spread.

Live data notice: Exchange rates are fetched live from a public exchange rate provider, not the Central Bank of Kenya. Rates reflect open market mid-rates and may differ slightly from bank or forex bureau rates. Data is cached for 1 hour to ensure fast responses.

GET

/exchange-rates

Returns live KES exchange rates for 25 currencies. Rates are fetched from open.er-api.com and cached server-side for 1 hour. Supports ?q= to filter by currency code or name.

curl -X GET "https://kenya-api.netlify.app/api/v1/exchange-rates" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/exchange-rates", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/exchange-rates"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/exchange-rates";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/exchange-rates"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/exchange-rates")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/exchange-rates"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "base_currency": "KES",
  "last_updated": "Wed, 17 Jun 2026 00:02:31 +0000",
  "next_update": "Thu, 18 Jun 2026 00:17:01 +0000",
  "source": "open.er-api.com (live mid-market rates)",
  "count": 25,
  "data": [
    {
      "id": 1,
      "currency": "USD",
      "currency_name": "US Dollar",
      "buy": 129.04,
      "mean": 129.43,
      "sell": 129.82
    },
    "..."
  ]
}

// Click "Try It" to fetch live data from the API

GET

/exchange-rates/:currency

Returns the live KES rate for a specific currency. Case-insensitive.

Name	Type	In	Required	Description
currency	string	path	yes	ISO 4217 code (e.g. USD, EUR, GBP). Case-insensitive. Available codes: USD, GBP, EUR, JPY, ZAR, AED, CAD, AUD, CHF, CNY, INR, SEK, NOK, DKK, SAR, QAR, HKD, SGD, UGX, TZS, RWF, ETB, NGN, ZMW, MUR

curl -X GET "https://kenya-api.netlify.app/api/v1/exchange-rates/USD" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/exchange-rates/USD", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/exchange-rates/USD"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/exchange-rates/USD";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/exchange-rates/USD"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/exchange-rates/USD")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/exchange-rates/USD"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "base_currency": "KES",
  "last_updated": "Wed, 17 Jun 2026 00:02:31 +0000",
  "source": "open.er-api.com (live mid-market rates)",
  "data": {
    "id": 1,
    "currency": "USD",
    "currency_name": "US Dollar",
    "buy": 129.04,
    "mean": 129.43,
    "sell": 129.82
  }
}

// Click "Try It" to fetch live data from the API

Educational Institutions

Kenya's educational institutions covering 53 universities (41 public + 12 private chartered) accredited by CUE and 613 TVET institutions accredited by TVETA, including National Polytechnics, Technical Training Institutes, and Vocational Training Centers across all 47 counties.

GET

/institutions

Returns institutions with optional pagination or filters.

Name	Type	In	Required	Description
page	integer	query	no	Page number for pagination
limit	integer	query	no	Maximum items per page
type	string	query	no	Institution type (University, TVET, Secondary School, Primary School, College)
category	string	query	no	Institution category (Public, Private, Faith-Based, Technical)
initials	string	query	no	Filter by university initials e.g. UON, JKUAT, KU

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 10,
  "page": 1,
  "data": [ ... ]
}

GET

/institutions/universities

Returns all universities in Kenya — both public (41) and private (12) — accredited by the Commission for University Education (CUE). Sorted alphabetically. Filter by ?category=Public or ?category=Private.

Name	Type	In	Required	Description
category	string	query	no	Public or Private
county_id	integer	query	no	Filter by county ID e.g. 47 for Nairobi

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/universities" \
  -H "Accept: application/json"

# Public universities only
curl "https://kenya-api.netlify.app/api/v1/institutions/universities?category=Public"

# Private universities only
curl "https://kenya-api.netlify.app/api/v1/institutions/universities?category=Private"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/universities", {
  method: "GET",
  headers: { "Accept": "application/json" }
});
const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/universities"
headers = {"Accept": "application/json"}

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

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/universities";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Accept: application/json"]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/universities"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/universities")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"
response = http.request(request)
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/universities"))
      .header("Accept", "application/json")
      .GET()
      .build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 53,
  "public_count": 41,
  "private_count": 12,
  "accreditor": "Commission for University Education (CUE)",
  "data": [
    {
      "id": 689,
      "name": "Strathmore University",
      "initials": "SU",
      "type": "University",
      "category": "Private",
      "county_id": 47,
      "county_name": "Nairobi",
      "address": "Ole Sangale Road, Madaraka Estate, Nairobi",
      "phone": "+254 703 034 000",
      "email": "admissions@strathmore.edu",
      "website": "https://www.strathmore.edu",
      "description": "A Nairobi-based institution emphasising high standards of teaching, research, and student welfare...",
      "accredited_by": "Commission for University Education (CUE)"
    },
    "..."
  ]
}

// Click "Try It" to fetch live data from the API

GET

/institutions/tvets

Returns all TVET institutions accredited by TVETA — including National Polytechnics, Technical Training Institutes, and Vocational Training Centers. Supports ?subtype=, ?category=, and ?county_id= filters.

Name	Type	In	Required	Description
subtype	string	query	no	`polytechnic` = National Polytechnics only · `tvc` = TVCs and TTIs only
category	string	query	no	Public or Private
county_id	integer	query	no	Filter by county ID e.g. 47 for Nairobi

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/tvets" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/tvets", {
  method: "GET",
  headers: { "Accept": "application/json" }
});
const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/tvets"
headers = {"Accept": "application/json"}

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

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/tvets";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Accept: application/json"]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/tvets"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/tvets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"
response = http.request(request)
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/tvets"))
      .header("Accept", "application/json")
      .GET()
      .build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 613,
  "accreditor": "Technical and Vocational Education and Training Authority (TVETA)",
  "data": [
    {
      "id": 109,
      "name": "ABC Kivi VTC",
      "type": "Technical and Vocational College (TVET)",
      "category": "Public",
      "county_id": 16,
      "county_name": "Machakos",
      "accredited_by": "Technical and Vocational Education and Training Authority (TVETA)"
    },
    "..."
  ]
}

// Click "Try It" to fetch live data from the API

GET

/institutions/:id

Returns a single institution by ID.

Name	Type	In	Required	Description
id	integer	path	yes	Institution ID

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/1", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/1"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/1";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/1"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/1"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1, "name": "Technical University of Mombasa"
  }
}

GET

/institutions/county/:county_id

Returns institutions in a given county.

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID from 1 to 47

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/county/47" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/county/47", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/county/47"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/county/47";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/county/47"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/county/47")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/county/47"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 4,
  "data": [ ... ]
}

GET

/institutions/type/:type

Returns all institutions matching the requested type.

Name	Type	In	Required	Description
type	string	path	yes	Valid institution type, e.g. University

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/type/University" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/type/University", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/type/University"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/type/University";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/type/University"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/type/University")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/type/University"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

GET

/institutions/search?q=...

Search institutions by name, address, county, or constituency.

Name	Type	In	Required	Description
q	string	query	yes	Search term, at least 2 characters

curl -X GET "https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/institutions/search?q=nairobi"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Ministries

Kenya's 22 Cabinet Secretaries and their ministries, sourced from the Office of the President. Includes ministry name, cabinet secretary, appointment year, official image, and ministry website.

GET

/ministries

Returns all 22 ministries and their Cabinet Secretaries. Supports ?appointed=2022 or ?appointed=2024 to filter by appointment year.

Name	Type	In	Required	Description
appointed	string	query	no	Filter by appointment year, e.g. 2022, 2024

curl -X GET "https://kenya-api.netlify.app/api/v1/ministries" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/ministries", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/ministries"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/ministries";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/ministries"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/ministries")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/ministries"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 22,
  "source": "Office of the President of Kenya",
  "data": [
    {
      "id": 1,
      "ministry": "Foreign and Diaspora Affairs",
      "cabinet_secretary": "Dr. Musalia Mudavadi E.G.H.",
      "title": "Prime Cabinet Secretary and Cabinet Secretary",
      "appointed": "2022",
      "image_url": "https://www.president.go.ke/wp-content/uploads/Mudavadi.jpg",
      "ministry_website": "https://www.mfa.go.ke",
      "source": "https://www.president.go.ke/cabinet/"
    }
  ]
}

{
  "success": true,
  "count": 22,
  "source": "Office of the President of Kenya",
  "data": [
    { "id": 1, "ministry": "Foreign and Diaspora Affairs", "cabinet_secretary": "Dr. Musalia Mudavadi E.G.H." },
    "..."
  ]
}

GET

/ministries/:id

Returns a single ministry by numeric ID (1–22).

Name	Type	In	Required	Description
id	integer	path	yes	Ministry ID from 1 to 22

curl -X GET "https://kenya-api.netlify.app/api/v1/ministries/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/ministries/1", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/ministries/1"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/ministries/1";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/ministries/1"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/ministries/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/ministries/1"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1,
    "ministry": "Foreign and Diaspora Affairs",
    "cabinet_secretary": "Dr. Musalia Mudavadi E.G.H.",
    "title": "Prime Cabinet Secretary and Cabinet Secretary",
    "appointed": "2022",
    "image_url": "https://www.president.go.ke/wp-content/uploads/Mudavadi.jpg",
    "ministry_website": "https://www.mfa.go.ke",
    "source": "https://www.president.go.ke/cabinet/"
  }
}

{
  "success": true,
  "data": {
    "id": 1, "ministry": "Foreign and Diaspora Affairs",
    "cabinet_secretary": "Dr. Musalia Mudavadi E.G.H.",
    "appointed": "2022"
  }
}

GET

/ministries/search?q=

Search ministries by ministry name or cabinet secretary name. Minimum 2 characters required.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars) — searches ministry name and cabinet secretary name

curl -X GET "https://kenya-api.netlify.app/api/v1/ministries/search?q=health" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/ministries/search?q=health", {
  method: "GET",
  headers: {
    "Accept": "application/json"
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/ministries/search?q=health"
headers = {"Accept": "application/json"}

response = requests.get(url, headers=headers)
data = response.json()
print(data)

<?php
$url = "https://kenya-api.netlify.app/api/v1/ministries/search?q=health";
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Accept: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/ministries/search?q=health"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/ministries/search?q=health")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
puts data

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/ministries/search?q=health"))
      .header("Accept", "application/json")
      .GET()
      .build();

    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "health",
  "count": 1,
  "data": [
    { "id": 5, "ministry": "Health", "cabinet_secretary": "Aden Duale E.G.H." }
  ]
}

{
  "success": true,
  "query": "health",
  "count": 1,
  "data": [
    { "id": 5, "ministry": "Health", "cabinet_secretary": "Aden Duale E.G.H." }
  ]
}

Postal Codes

Kenya postal codes mapped to all 47 counties and their constituencies. Sourced from Posta Kenya and PostZipCode.com.

GET

/postal-codes

Returns postal code data for all 47 counties, including constituency-level codes and the county primary postal code range.

curl -X GET "https://kenya-api.netlify.app/api/v1/postal-codes" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/postal-codes", {
  method: "GET",
  headers: { "Accept": "application/json" }
});
const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/postal-codes"
response = requests.get(url, headers={"Accept": "application/json"})
print(response.json())

<?php
$ch = curl_init("https://kenya-api.netlify.app/api/v1/postal-codes");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Accept: application/json"]);
print_r(json_decode(curl_exec($ch), true));
curl_close($ch);
?>

package main

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

func main() {
  req, _ := http.NewRequest("GET", "https://kenya-api.netlify.app/api/v1/postal-codes", nil)
  req.Header.Set("Accept", "application/json")
  resp, _ := http.DefaultClient.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/postal-codes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
req = Net::HTTP::Get.new(url)
req["Accept"] = "application/json"
puts JSON.parse(http.request(req).body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/postal-codes"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "count": 47,
  "source": "Posta Kenya / PostZipCode.com",
  "data": [
    {
      "id": 1,
      "county_id": 1,
      "county_name": "Mombasa",
      "postal_code_range": { "from": "80100", "to": "80118" },
      "primary_postal_code": "80100",
      "constituencies": [ "..." ]
    }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/postal-codes/county/:county_id

Returns postal code data for a single county by its numeric ID, including all constituency-level codes.

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID (1–47)

curl -X GET "https://kenya-api.netlify.app/api/v1/postal-codes/county/47" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/postal-codes/county/47");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/postal-codes/county/47")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/postal-codes/county/47");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/postal-codes/county/47")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"
puts JSON.parse(Net::HTTP.get(URI("https://kenya-api.netlify.app/api/v1/postal-codes/county/47")))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/postal-codes/county/47"))
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response (Nairobi)

{
  "success": true,
  "data": {
    "county_id": 47,
    "county_name": "Nairobi",
    "primary_postal_code": "00100",
    "postal_code_range": { "from": "00100", "to": "00800" },
    "constituencies": [
      { "name": "Westlands", "postal_code": "00600" },
      { "name": "Kamukunji", "postal_code": "00200" },
      "..."
    ]
  }
}

// Click "Try It" to fetch live data from the API

GET

/postal-codes/constituency

Looks up postal codes by constituency name. Partial, case-insensitive match. Returns county context and the county-level range.

Name	Type	In	Required	Description
name	string	query	yes	Constituency name or partial name (e.g. `Westlands`)

curl -X GET "https://kenya-api.netlify.app/api/v1/postal-codes/constituency?name=Westlands" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/postal-codes/constituency?name=Westlands");
const data = await response.json();
console.log(data);

import requests
response = requests.get(
  "https://kenya-api.netlify.app/api/v1/postal-codes/constituency",
  params={"name": "Westlands"}
)
print(response.json())

<?php
$url = "https://kenya-api.netlify.app/api/v1/postal-codes/constituency?" . http_build_query(["name" => "Westlands"]);
print_r(json_decode(file_get_contents($url), true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/postal-codes/constituency?name=Westlands")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"
puts JSON.parse(Net::HTTP.get(URI("https://kenya-api.netlify.app/api/v1/postal-codes/constituency?name=Westlands")))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/postal-codes/constituency?name=Westlands"))
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "count": 1,
  "data": [
    {
      "county_id": 47,
      "county_name": "Nairobi",
      "constituency": "Westlands",
      "postal_code": "00600",
      "county_postal_range": { "from": "00100", "to": "00800" }
    }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/postal-codes/search

Search postal codes by county name, constituency name, or code number. Returns typed results (county or constituency) in a single list.

Name	Type	In	Required	Description
q	string	query	yes	Search term — county name, constituency name, or code (min 2 chars)

curl -X GET "https://kenya-api.netlify.app/api/v1/postal-codes/search?q=00100" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/postal-codes/search?q=00100");
const data = await response.json();
console.log(data);

import requests
response = requests.get(
  "https://kenya-api.netlify.app/api/v1/postal-codes/search",
  params={"q": "00100"}
)
print(response.json())

<?php
$url = "https://kenya-api.netlify.app/api/v1/postal-codes/search?" . http_build_query(["q" => "00100"]);
print_r(json_decode(file_get_contents($url), true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/postal-codes/search?q=00100")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"
puts JSON.parse(Net::HTTP.get(URI("https://kenya-api.netlify.app/api/v1/postal-codes/search?q=00100")))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/postal-codes/search?q=00100"))
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "query": "00100",
  "count": 12,
  "data": [
    {
      "type": "county",
      "county_name": "Nairobi",
      "primary_postal_code": "00100"
    },
    {
      "type": "constituency",
      "county_name": "Nairobi",
      "constituency": "Starehe",
      "postal_code": "00100"
    },
    "..."
  ]
}

// Click "Try It" to fetch live data from the API

Wards

Kenya's 1,263 electoral wards organised by county and sub-county. Data sourced from the IEBC via an open CC0 dataset on GitHub. Covers 45 of 47 counties (Nairobi, Kericho, and Bomet are not in the upstream source).

GET

/wards

All wards with optional filters. Paginated — default 50 per page.

Name	Type	In	Required	Description
county_id	integer	query	no	Filter by county ID (1–47)
sub_county	string	query	no	Filter by sub-county name (partial match)
page	integer	query	no	Page number (default: 1)
limit	integer	query	no	Results per page (default: 50)

curl -X GET "https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/wards", params={"county_id": 1, "limit": 50})
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50")
puts JSON.parse(Net::HTTP.get(url))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/wards?county_id=1&limit=50"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "total": 30,
  "count": 30,
  "page": 1,
  "totalPages": 1,
  "data": [
    {
      "id": 1,
      "sub_county_id": 1,
      "sub_county_name": "Changamwe",
      "county_id": 1,
      "county_name": "Mombasa",
      "ward": "Port Reitz"
    }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/wards/county/:county_id

All wards in a county grouped by sub-county. Ideal for building cascading dropdowns (county → sub-county → ward).

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID (1–47)

curl -X GET "https://kenya-api.netlify.app/api/v1/wards/county/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/wards/county/1");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/wards/county/1")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/wards/county/1");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/wards/county/1")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/wards/county/1")
puts JSON.parse(Net::HTTP.get(url))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/wards/county/1"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "county_id": 1,
  "county_name": "Mombasa",
  "sub_counties": 6,
  "ward_count": 30,
  "data": [
    {
      "sub_county_id": 1,
      "sub_county_name": "Changamwe",
      "wards": [ "Port Reitz", "Kipevu", "Airport", "Changamwe", "Chaani" ]
    }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/wards/sub-county?name=

Returns all wards for a specific sub-county by name. Partial name matches are supported.

Name	Type	In	Required	Description
name	string	query	yes	Sub-county name or partial name (e.g. `Changamwe`)

curl -X GET "https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/wards/sub-county", params={"name": "Changamwe"})
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe")
puts JSON.parse(Net::HTTP.get(url))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/wards/sub-county?name=Changamwe"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

// Click "Try It" to fetch live data from the API

GET

/wards/sub-counties/:county_id

Returns only the list of sub-counties in a county — no ward details. Lightweight endpoint for populating dropdowns.

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID (1–47)

curl -X GET "https://kenya-api.netlify.app/api/v1/wards/sub-counties/1" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1")
puts JSON.parse(Net::HTTP.get(url))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/wards/sub-counties/1"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

Example response

{
  "success": true,
  "county_id": 1,
  "county_name": "Mombasa",
  "count": 6,
  "data": [
    { "sub_county_id": 1, "sub_county_name": "Changamwe", "county_id": 1, "county_name": "Mombasa" },
    { "sub_county_id": 2, "sub_county_name": "Jomvu", "county_id": 1, "county_name": "Mombasa" }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/wards/search?q=

Search ward names, sub-county names, or county names. Returns all matching ward records. Minimum 2 characters.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars) — matches ward, sub-county, or county name

curl -X GET "https://kenya-api.netlify.app/api/v1/wards/search?q=karen" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/wards/search?q=karen");
const data = await response.json();
console.log(data);

import requests
response = requests.get("https://kenya-api.netlify.app/api/v1/wards/search", params={"q": "karen"})
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/wards/search?q=karen");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/wards/search?q=karen")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/wards/search?q=karen")
puts JSON.parse(Net::HTTP.get(url))

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/wards/search?q=karen"))
      .header("Accept", "application/json")
      .GET().build();
    System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
  }
}

// Click "Try It" to fetch live data from the API

Parks & Reserves

Kenya's 35 national parks, reserves, marine parks, and wildlife sanctuaries managed by Kenya Wildlife Service (KWS). Includes location, size, coordinates, wildlife highlights, and conservation status.

GET

/parks

Returns all parks and reserves with optional filters by type, county, or wildlife features.

Name	Type	In	Required	Description
type	string	query	no	National Park, National Reserve, Marine Park & Reserve, Wildlife Sanctuary
county_id	integer	query	no	Filter by county ID e.g. 32 for Nakuru
big_cats	boolean	query	no	`true` = parks with lions, leopards, or cheetahs
marine	boolean	query	no	`true` = marine parks only
most_visited	boolean	query	no	`true` = most popular parks

curl -X GET "https://kenya-api.netlify.app/api/v1/parks" \
  -H "Accept: application/json"

# Most visited parks
curl "https://kenya-api.netlify.app/api/v1/parks?most_visited=true"

# Marine parks only
curl "https://kenya-api.netlify.app/api/v1/parks?marine=true"

# Parks with big cats
curl "https://kenya-api.netlify.app/api/v1/parks?big_cats=true"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parks", {
  method: "GET",
  headers: { "Accept": "application/json" }
});
const data = await response.json();
console.log(data);

import requests

url = "https://kenya-api.netlify.app/api/v1/parks"
headers = {"Accept": "application/json"}

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

<?php
$url = "https://kenya-api.netlify.app/api/v1/parks";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Accept: application/json"]);
$response = curl_exec($ch);
curl_close($ch);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  url := "https://kenya-api.netlify.app/api/v1/parks"
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Accept", "application/json")
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"
response = http.request(request)
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parks"))
      .header("Accept", "application/json")
      .GET()
      .build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 35,
  "managed_by": "Kenya Wildlife Service (KWS)",
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/parks/:id

Returns a single park by its numeric ID.

Name	Type	In	Required	Description
id	integer	path	yes	Park ID e.g. 2 for Amboseli

curl -X GET "https://kenya-api.netlify.app/api/v1/parks/2" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parks/2");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parks/2")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parks/2");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parks/2")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parks/2")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parks/2"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 2,
    "name": "Amboseli National Park",
    "type": "National Park",
    "county_ids": [34],
    "counties": ["Kajiado"],
    "region": "Southern Kenya",
    "famous_for": "Elephants & Mount Kilimanjaro views",
    "description": "One of Kenya's most iconic parks...",
    "size_km2": 392,
    "managed_by": "Kenya Wildlife Service (KWS)",
    "big_cats": true,
    "marine": false,
    "most_visited": true,
    "coordinates": { "lat": -2.6527, "lng": 37.2606 }
  }
}

// Click "Try It" to fetch live data from the API

GET

/parks/county/:county_id

Returns all parks in a given county. Parks that span multiple counties appear in each relevant county's results.

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID e.g. 32 for Nakuru (returns Hell's Gate, Lake Nakuru, Mt Longonot, Lake Elementaita)

curl -X GET "https://kenya-api.netlify.app/api/v1/parks/county/32" \
  -H "Accept: application/json"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parks/county/32");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parks/county/32")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parks/county/32");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parks/county/32")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parks/county/32")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parks/county/32"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "county_id": 32,
  "count": 4,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/parks/type/:type

Returns all parks of a specific type. URL-encode spaces and ampersands in the type parameter.

Name	Type	In	Required	Description
type	string	path	yes	National Park · National Reserve · Marine Park & Reserve · Wildlife Sanctuary

# All national parks
curl "https://kenya-api.netlify.app/api/v1/parks/type/National%20Park"

# Marine parks and reserves
curl "https://kenya-api.netlify.app/api/v1/parks/type/Marine%20Park%20%26%20Reserve"

const type = encodeURIComponent("National Park");
const response = await fetch(
  `https://kenya-api.netlify.app/api/v1/parks/type/${type}`
);
const data = await response.json();
console.log(data);

import requests
from urllib.parse import quote

park_type = quote("National Park")
response = requests.get(
  f"https://kenya-api.netlify.app/api/v1/parks/type/{park_type}"
)
print(response.json())

<?php
$type = urlencode("National Park");
$response = file_get_contents(
  "https://kenya-api.netlify.app/api/v1/parks/type/{$type}"
);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  parkType := url.PathEscape("National Park")
  resp, _ := http.Get(
    "https://kenya-api.netlify.app/api/v1/parks/type/" + parkType,
  )
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"
require "uri"

type = URI.encode_uri_component("National Park")
url = URI("https://kenya-api.netlify.app/api/v1/parks/type/#{type}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;

public class Main {
  public static void main(String[] args) throws Exception {
    String type = URLEncoder.encode("National Park", StandardCharsets.UTF_8)
      .replace("+", "%20");
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create(
        "https://kenya-api.netlify.app/api/v1/parks/type/" + type
      ))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "type": "National Park",
  "count": 22,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/parks/search?q=

Search parks by name, famous_for, description, region, or county. Minimum 2 characters.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 characters) e.g. elephant, coral, rift

curl "https://kenya-api.netlify.app/api/v1/parks/search?q=elephant"

const response = await fetch(
  "https://kenya-api.netlify.app/api/v1/parks/search?q=elephant"
);
const data = await response.json();
console.log(data);

import requests

response = requests.get(
  "https://kenya-api.netlify.app/api/v1/parks/search",
  params={"q": "elephant"}
)
print(response.json())

<?php
$response = file_get_contents(
  "https://kenya-api.netlify.app/api/v1/parks/search?q=elephant"
);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get(
    "https://kenya-api.netlify.app/api/v1/parks/search?q=elephant",
  )
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parks/search?q=elephant")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create(
        "https://kenya-api.netlify.app/api/v1/parks/search?q=elephant"
      ))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "elephant",
  "count": 10,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

Presidents

All Heads of State of Kenya since independence in 1963, including term dates, political parties, deputies, and key facts. Sourced from Wikipedia and Kenyan constitutional records.

GET

/presidents

Returns all 5 presidents since the republic was established in 1964. Supports ?party= filter and ?include_pre_republic=true to include the brief 1963–64 constitutional monarchy period.

Name	Type	In	Required	Description
party	string	query	no	Filter by party e.g. `KANU`, `UDA`
include_pre_republic	boolean	query	no	Set `true` to include Queen Elizabeth II / Governor-General period (1963–1964)

curl "https://kenya-api.netlify.app/api/v1/presidents"

# Filter by party
curl "https://kenya-api.netlify.app/api/v1/presidents?party=KANU"

# Include pre-republic period
curl "https://kenya-api.netlify.app/api/v1/presidents?include_pre_republic=true"

const response = await fetch("https://kenya-api.netlify.app/api/v1/presidents");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/presidents")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/presidents");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/presidents")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/presidents")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/presidents"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 5,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/presidents/:id

Returns a single president by numeric ID (1–5).

Name	Type	In	Required	Description
id	integer	path	yes	President ID — 1 (Kenyatta) through 5 (Ruto)

curl "https://kenya-api.netlify.app/api/v1/presidents/1"

const response = await fetch("https://kenya-api.netlify.app/api/v1/presidents/1");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/presidents/1")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/presidents/1");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/presidents/1")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/presidents/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/presidents/1"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1,
    "order": 1,
    "name": "Jomo Kenyatta",
    "full_title": "President of Kenya",
    "birth_year": 1897,
    "took_office": "1964-12-12",
    "left_office": "1978-08-22",
    "time_in_office": "13 years, 253 days",
    "political_party": "KANU",
    "deputies": ["Jaramogi Oginga Odinga", "..."],
    "died_in_office": true,
    "is_incumbent": false
  }
}

// Click "Try It" to fetch live data from the API

GET

/presidents/incumbent

Returns the current sitting president — the entry where is_incumbent is true.

curl "https://kenya-api.netlify.app/api/v1/presidents/incumbent"

const response = await fetch("https://kenya-api.netlify.app/api/v1/presidents/incumbent");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/presidents/incumbent")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/presidents/incumbent");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/presidents/incumbent")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/presidents/incumbent")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/presidents/incumbent"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 5,
    "name": "William Ruto",
    "political_party": "UDA",
    "took_office": "2022-09-13",
    "left_office": null,
    "time_in_office": "Incumbent",
    "deputies": ["Rigathi Gachagua", "Kithure Kindiki"],
    "is_incumbent": true
  }
}

// Click "Try It" to fetch live data from the API

GET

/presidents/search?q=

Search presidents by name, political party, deputies, or description. Minimum 2 characters.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars) — searches name, party, deputies, description

curl "https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto"
curl "https://kenya-api.netlify.app/api/v1/presidents/search?q=KANU"

const response = await fetch(
  "https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto"
);
const data = await response.json();
console.log(data);

import requests

response = requests.get(
  "https://kenya-api.netlify.app/api/v1/presidents/search",
  params={"q": "ruto"}
)
print(response.json())

<?php
$response = file_get_contents(
  "https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto"
);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get(
    "https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto",
  )
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create(
        "https://kenya-api.netlify.app/api/v1/presidents/search?q=ruto"
      ))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "ruto",
  "count": 2,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

Parastatals & State Corporations

Kenya's 246 state corporations and parastatals established under the State Corporations Act, Cap 446, or by Acts of Parliament. Includes sector classification and cross-references to universities already covered in the Institutions endpoint.

Note: Universities listed here (flagged with is_university: true) are also fully documented with contact details, county location, and accreditation in the Institutions endpoint.

GET

/parastatals

Returns all 246 state corporations with optional filtering by sector, university flag, or free-text search. Results are paginated (default 50 per page). The response includes total, page, and totalPages for pagination.

Name	Type	In	Required	Description
sector	string	query	no	Filter by sector e.g. `Health`, `Energy`, `Education & Research`
is_university	boolean	query	no	Set `false` to exclude universities; `true` to return only university entries
q	string	query	no	Search by name or abbreviation
page	integer	query	no	Page number (default 1)
limit	integer	query	no	Results per page (default 50)

curl "https://kenya-api.netlify.app/api/v1/parastatals"

# Filter by sector
curl "https://kenya-api.netlify.app/api/v1/parastatals?sector=Health"

# Exclude universities
curl "https://kenya-api.netlify.app/api/v1/parastatals?is_university=false"

# Paginate
curl "https://kenya-api.netlify.app/api/v1/parastatals?page=2&limit=25"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parastatals");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parastatals")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parastatals");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parastatals")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parastatals")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parastatals"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "total": 246,
  "count": 50,
  "page": 1,
  "totalPages": 5,
  "established_under": "State Corporations Act, Cap 446",
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/parastatals/:id

Returns a single parastatal by numeric ID (1–246).

Name	Type	In	Required	Description
id	integer	path	yes	Numeric ID 1–246

curl "https://kenya-api.netlify.app/api/v1/parastatals/107"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parastatals/107");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parastatals/107")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parastatals/107");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parastatals/107")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parastatals/107")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parastatals/107"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 107,
    "name": "Kenya Power and Lighting Company Ltd",
    "abbreviation": "KPLC",
    "sector": "Energy",
    "category": "State Corporation",
    "established_by": "State Corporations Act, Cap 446",
    "is_university": false
  }
}

// Click "Try It" to fetch live data from the API

GET

/parastatals/sector/:sector

Returns all parastatals in a given sector. The sector value is URL-decoded so spaces work naturally (e.g. Land%20%26%20Water or Education%20%26%20Research).

Name	Type	In	Required	Description
sector	string	path	yes	Sector name e.g. `Health`, `Energy`, `Land%20%26%20Water`

curl "https://kenya-api.netlify.app/api/v1/parastatals/sector/Health"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parastatals/sector/Health"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "sector": "Health",
  "count": 13,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/parastatals/sectors

Returns a breakdown of all 16 sectors with entity counts, sorted by count descending. Useful for building filter UIs or sector-selector dropdowns.

curl "https://kenya-api.netlify.app/api/v1/parastatals/sectors"

const response = await fetch("https://kenya-api.netlify.app/api/v1/parastatals/sectors");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/parastatals/sectors")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/parastatals/sectors");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parastatals/sectors")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parastatals/sectors")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parastatals/sectors"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 15,
  "data": [
    { "sector": "Education & Research", "count": 65 },
    { "sector": "Agriculture", "count": 30 },
    { "sector": "Land & Water", "count": 23 },
    "..."
  ]
}

// Click "Try It" to fetch live data from the API

GET

/parastatals/search?q=

Search parastatals by name, abbreviation, or sector. Minimum 2 characters required.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars) — matched against name, abbreviation, and sector

curl "https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA"
curl "https://kenya-api.netlify.app/api/v1/parastatals/search?q=energy"

const response = await fetch(
  "https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA"
);
const data = await response.json();
console.log(data);

import requests

response = requests.get(
  "https://kenya-api.netlify.app/api/v1/parastatals/search",
  params={"q": "KRA"}
)
print(response.json())

<?php
$response = file_get_contents(
  "https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA"
);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/parastatals/search?q=KRA"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "KRA",
  "count": 1,
  "data": [
    {
      "id": 109,
      "name": "Kenya Revenue Authority",
      "abbreviation": "KRA",
      "sector": "Finance & Regulation"
    }
  ]
}

// Click "Try It" to fetch live data from the API

Lakes

Kenya's 18 named lakes including Lake Victoria, Lake Turkana, and the Rift Valley soda lakes. Includes location, surface area, lake type, and key features. Sourced from 33travels.com.

GET

/lakes

Returns all 18 lakes. Supports filtering by ?type= (Freshwater, Saline/Alkaline, Crater Lake), ?rift_valley=true, ?transboundary=true, and ?sort=size_desc or ?sort=size_asc.

Name	Type	In	Required	Description
type	string	query	no	Filter by lake type: `Freshwater`, `Saline/Alkaline`, or `Crater Lake`
rift_valley	boolean	query	no	Set `true` to return only Rift Valley lakes
transboundary	boolean	query	no	Set `true` to return only lakes shared with neighbouring countries
sort	string	query	no	Sort by surface area: `size_desc` (largest first) or `size_asc`

curl "https://kenya-api.netlify.app/api/v1/lakes"

# Largest first
curl "https://kenya-api.netlify.app/api/v1/lakes?sort=size_desc"

# Rift Valley lakes only
curl "https://kenya-api.netlify.app/api/v1/lakes?rift_valley=true"

# Freshwater lakes only
curl "https://kenya-api.netlify.app/api/v1/lakes?type=Freshwater"

# Transboundary lakes
curl "https://kenya-api.netlify.app/api/v1/lakes?transboundary=true"

const response = await fetch("https://kenya-api.netlify.app/api/v1/lakes");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/lakes")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/lakes");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/lakes")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/lakes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/lakes"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 18,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/lakes/:id

Returns a single lake by numeric ID (1–18).

Name	Type	In	Required	Description
id	integer	path	yes	Numeric ID 1–18

curl "https://kenya-api.netlify.app/api/v1/lakes/2"

const response = await fetch("https://kenya-api.netlify.app/api/v1/lakes/2");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/lakes/2")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/lakes/2");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/lakes/2")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/lakes/2")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/lakes/2"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 2,
    "name": "Lake Turkana",
    "county_ids": [23],
    "counties": ["Turkana"],
    "region": "Rift Valley",
    "surface_area_km2": 6405,
    "lake_type": "Saline/Alkaline",
    "key_feature": "Largest desert lake; rich in fossils",
    "is_rift_valley": true,
    "transboundary": false
  }
}

// Click "Try It" to fetch live data from the API

GET

/lakes/county/:county_id

Returns all lakes within a specific county. Lakes that span multiple counties appear in each county's results.

Name	Type	In	Required	Description
county_id	integer	path	yes	County ID (1–47)

curl "https://kenya-api.netlify.app/api/v1/lakes/county/32"

const response = await fetch("https://kenya-api.netlify.app/api/v1/lakes/county/32");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/lakes/county/32")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/lakes/county/32");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/lakes/county/32")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/lakes/county/32")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/lakes/county/32"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "county_id": 32,
  "count": 5,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/lakes/search?q=

Search lakes by name, key feature, description, or county name. Minimum 2 characters required.

Name	Type	In	Required	Description
q	string	query	yes	Search term (min 2 chars) — matched against name, key_feature, description, and county

curl "https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo"
curl "https://kenya-api.netlify.app/api/v1/lakes/search?q=rift"

const response = await fetch(
  "https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo"
);
const data = await response.json();
console.log(data);

import requests

response = requests.get(
  "https://kenya-api.netlify.app/api/v1/lakes/search",
  params={"q": "flamingo"}
)
print(response.json())

<?php
$response = file_get_contents(
  "https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo"
);
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/lakes/search?q=flamingo"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "flamingo",
  "count": 6,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

Rivers

Kenya's 12 major rivers including the Tana, Ewaso Nyiro, and Mara, with length, source, mouth, and drainage system. Sourced from abiri.home.blog.

GET

/rivers

Returns all 12 rivers. Supports ?sort=length_desc or ?sort=length_asc and filtering by ?drainage_system= (Indian Ocean Drainage, Lake Victoria Drainage, Lake Turkana Drainage, Lake Natron Drainage).

Name	Type	In	Required	Description
sort	string	query	no	Sort by length: `length_desc` (longest first) or `length_asc`
drainage_system	string	query	no	Filter by drainage system, e.g. `Indian Ocean Drainage`

curl "https://kenya-api.netlify.app/api/v1/rivers"

# Longest first
curl "https://kenya-api.netlify.app/api/v1/rivers?sort=length_desc"

# Lake Victoria drainage rivers
curl "https://kenya-api.netlify.app/api/v1/rivers?drainage_system=Lake%20Victoria%20Drainage"

const response = await fetch("https://kenya-api.netlify.app/api/v1/rivers");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/rivers")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/rivers");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/rivers")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/rivers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/rivers"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "count": 12,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/rivers/:id

Returns a single river by numeric ID (1–12). Example: /rivers/1 returns the Tana River.

curl "https://kenya-api.netlify.app/api/v1/rivers/1"

const response = await fetch("https://kenya-api.netlify.app/api/v1/rivers/1");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/rivers/1")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/rivers/1");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/rivers/1")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/rivers/1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/rivers/1"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "data": {
    "id": 1,
    "name": "Tana River",
    "length_km": 1000,
    "source": "Aberdare Ranges and Mount Kenya",
    "mouth": "Indian Ocean",
    "drainage_system": "Indian Ocean Drainage",
    "is_longest": true,
    "counties": ["Nyeri", "Nyandarua", "Machakos", "Kitui", "Tana River"]
  }
}

// Click "Try It" to fetch live data from the API

GET

/rivers/county/:county_id

Returns all rivers flowing through the given county. Example: /rivers/county/47 returns rivers in Nairobi (county_id 47).

curl "https://kenya-api.netlify.app/api/v1/rivers/county/47"

const response = await fetch("https://kenya-api.netlify.app/api/v1/rivers/county/47");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/rivers/county/47")
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/rivers/county/47");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/rivers/county/47")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/rivers/county/47")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/rivers/county/47"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "county_id": 47,
  "count": 1,
  "data": [
    {
      "id": 4,
      "name": "Athi-Galana-Sabaki",
      "length_km": 390,
      "drainage_system": "Indian Ocean Drainage"
    }
  ]
}

// Click "Try It" to fetch live data from the API

GET

/rivers/drainage/:system

Returns all rivers in a specific drainage system. Valid values: Indian Ocean Drainage, Lake Victoria Drainage, Lake Turkana Drainage, Lake Natron Drainage.

curl "https://kenya-api.netlify.app/api/v1/rivers/drainage/Lake%20Victoria%20Drainage"

const system = encodeURIComponent("Lake Victoria Drainage");
const response = await fetch(`https://kenya-api.netlify.app/api/v1/rivers/drainage/${system}`);
const data = await response.json();
console.log(data);

import requests
from urllib.parse import quote

system = quote("Lake Victoria Drainage")
response = requests.get(f"https://kenya-api.netlify.app/api/v1/rivers/drainage/{system}")
print(response.json())

<?php
$system = urlencode("Lake Victoria Drainage");
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/rivers/drainage/{$system}");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  system := url.PathEscape("Lake Victoria Drainage")
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/rivers/drainage/" + system)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"
require "uri"

system = URI.encode_uri_component("Lake Victoria Drainage")
url = URI("https://kenya-api.netlify.app/api/v1/rivers/drainage/#{system}")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;

public class Main {
  public static void main(String[] args) throws Exception {
    String system = URLEncoder.encode("Lake Victoria Drainage", StandardCharsets.UTF_8);
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/rivers/drainage/" + system))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "drainage_system": "Lake Victoria Drainage",
  "count": 5,
  "data": [ "..." ]
}

// Click "Try It" to fetch live data from the API

GET

/rivers/search?q=

Full-text search across river name, source, mouth, description, and counties. Minimum 2 characters. Example: ?q=tana.

curl "https://kenya-api.netlify.app/api/v1/rivers/search?q=tana"

const response = await fetch("https://kenya-api.netlify.app/api/v1/rivers/search?q=tana");
const data = await response.json();
console.log(data);

import requests

response = requests.get("https://kenya-api.netlify.app/api/v1/rivers/search", params={"q": "tana"})
print(response.json())

<?php
$response = file_get_contents("https://kenya-api.netlify.app/api/v1/rivers/search?q=tana");
print_r(json_decode($response, true));
?>

package main

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

func main() {
  resp, _ := http.Get("https://kenya-api.netlify.app/api/v1/rivers/search?q=tana")
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

require "net/http"
require "json"

url = URI("https://kenya-api.netlify.app/api/v1/rivers/search?q=tana")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(Net::HTTP::Get.new(url))
puts JSON.parse(response.body)

import java.net.URI;
import java.net.http.*;

public class Main {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://kenya-api.netlify.app/api/v1/rivers/search?q=tana"))
      .GET().build();
    HttpResponse<String> response = client.send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

Example response

{
  "success": true,
  "query": "tana",
  "count": 1,
  "data": [
    {
      "id": 1,
      "name": "Tana River",
      "length_km": 1000,
      "is_longest": true
    }
  ]
}

// Click "Try It" to fetch live data from the API