const API_KEY = 'hnsrd_your_key';
const BASE_URL = 'https://open.hnsrd.ai/v1';
const COUNTRY = 'AIA'; // Your authorized country code

// Fetch helper - always includes country parameter
async function apiRequest(endpoint, params = {}) {
  const url = new URL(BASE_URL + endpoint);
  params.country = COUNTRY; // Required on all requests
  Object.keys(params).forEach(key =>
    url.searchParams.append(key, params[key])
  );

  const response = await fetch(url, {
    headers: { 'X-API-Key': API_KEY }
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  return response.json();
}

// Get recent sittings
async function getSittings(page = 1, year = null) {
  const params = { page, per_page: 20 };
  if (year) params.year = year;
  return apiRequest('/sittings', params);
}

// Search speeches
async function searchSpeeches(query) {
  const data = await apiRequest('/speeches/search', { q: query });
  return data.data.results;
}

// Get member statistics
async function getMemberStats(memberId) {
  const data = await apiRequest(`/members/${memberId}/stats`);
  return data.data;
}

// Get bills in progress
async function getBillsInProgress() {
  const data = await apiRequest('/bills/in-progress');
  return data.data.bills;
}

// Usage
(async () => {
  // Get 2024 sittings
  const sittings = await getSittings(1, 2024);
  console.log(`Found ${sittings.meta.total} sittings in 2024`);

  // Search for education speeches
  const speeches = await searchSpeeches('education budget');
  console.log(`Found ${speeches.length} matching speeches`);

  // Get bills in progress
  const bills = await getBillsInProgress();
  bills.forEach(bill => {
    console.log(`${bill.bill_reference}: ${bill.title} (${bill.status})`);
  });
})();

import requests
from typing import Optional, Dict, Any, List

class OpenParliamentAPI:
    def __init__(self, api_key: str, country: str):
        self.api_key = api_key
        self.country = country  # Required: ISO 3166-1 alpha-3 code
        self.base_url = "https://open.hnsrd.ai/v1"
        self.session = requests.Session()
        self.session.headers.update({"X-API-Key": api_key})

    def _get(self, endpoint: str, params: Optional[Dict] = None) -> Dict[str, Any]:
        if params is None:
            params = {}
        params["country"] = self.country  # Always include country
        response = self.session.get(f"{self.base_url}{endpoint}", params=params)
        response.raise_for_status()
        data = response.json()
        if not data.get("success"):
            raise Exception(data.get("error", {}).get("message", "Unknown error"))
        return data

    def get_sittings(self, page: int = 1, year: Optional[int] = None) -> Dict:
        params = {"page": page}
        if year:
            params["year"] = year
        return self._get("/sittings", params)

    def get_sitting(self, sitting_id: str) -> Dict:
        return self._get(f"/sittings/{sitting_id}")

    def search_speeches(self, query: str, page: int = 1) -> Dict:
        return self._get("/speeches/search", {"q": query, "page": page})

    def get_members(self, page: int = 1, party: Optional[str] = None) -> Dict:
        params = {"page": page}
        if party:
            params["party"] = party
        return self._get("/members", params)

    def get_member_stats(self, member_id: str) -> Dict:
        return self._get(f"/members/{member_id}/stats")

    def get_bills(self, status: Optional[str] = None) -> Dict:
        endpoint = f"/bills/{status}" if status else "/bills"
        return self._get(endpoint)

    def search(self, query: str, type: str = "all") -> Dict:
        return self._get("/search", {"q": query, "type": type})

    def get_stats(self) -> Dict:
        return self._get("/stats")


# Usage - specify your authorized country code
api = OpenParliamentAPI("hnsrd_your_key", country="AIA")

# Get 2024 sittings
sittings = api.get_sittings(year=2024)
print(f"Found {sittings['meta']['total']} sittings in 2024")

# Search speeches
results = api.search_speeches("education budget")
for speech in results['data']['results'][:5]:
    print(f"{speech['speaker_name']}: {speech['text_preview'][:80]}...")

# Get bills in progress
bills = api.get_bills(status="in-progress")
for bill in bills['data']['bills']:
    print(f"{bill['bill_reference']}: {bill['title']} ({bill['status']})")

# Get parliamentary stats
stats = api.get_stats()
overview = stats['data']['overview']
print(f"\nParliamentary Statistics:")
print(f"  Total Sittings: {overview['total_sittings']}")
print(f"  Total Speeches: {overview['total_speeches']}")
print(f"  Total Members: {overview['total_members']}")

<?php

class OpenParliamentAPI {
    private string $apiKey;
    private string $country;
    private string $baseUrl = 'https://open.hnsrd.ai/v1';

    public function __construct(string $apiKey, string $country) {
        $this->apiKey = $apiKey;
        $this->country = $country; // Required: ISO 3166-1 alpha-3 code
    }

    private function request(string $endpoint, array $params = []): array {
        $params['country'] = $this->country; // Always include country
        $url = $this->baseUrl . $endpoint;
        if ($params) {
            $url .= '?' . http_build_query($params);
        }

        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_HTTPHEADER => ['X-API-Key: ' . $this->apiKey],
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 30
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode !== 200) {
            throw new Exception("API error: HTTP $httpCode");
        }

        $data = json_decode($response, true);
        if (!$data['success']) {
            throw new Exception($data['error']['message'] ?? 'Unknown error');
        }

        return $data;
    }

    public function getSittings(int $page = 1, ?int $year = null): array {
        $params = ['page' => $page];
        if ($year) $params['year'] = $year;
        return $this->request('/sittings', $params);
    }

    public function searchSpeeches(string $query, int $page = 1): array {
        return $this->request('/speeches/search', ['q' => $query, 'page' => $page]);
    }

    public function getMembers(int $page = 1, ?string $party = null): array {
        $params = ['page' => $page];
        if ($party) $params['party'] = $party;
        return $this->request('/members', $params);
    }

    public function getMemberStats(string $id): array {
        return $this->request("/members/$id/stats");
    }

    public function getBills(?string $status = null): array {
        $endpoint = $status ? "/bills/$status" : '/bills';
        return $this->request($endpoint);
    }

    public function search(string $query, string $type = 'all'): array {
        return $this->request('/search', ['q' => $query, 'type' => $type]);
    }

    public function getStats(): array {
        return $this->request('/stats');
    }
}

// Usage - specify your authorized country code
$api = new OpenParliamentAPI('hnsrd_your_key', 'AIA');

// Get 2024 sittings
$sittings = $api->getSittings(1, 2024);
echo "Found {$sittings['meta']['total']} sittings in 2024\n";

// Search speeches
$results = $api->searchSpeeches('education budget');
foreach (array_slice($results['data']['results'], 0, 5) as $speech) {
    echo "{$speech['speaker_name']}: " . substr($speech['text_preview'], 0, 80) . "...\n";
}

// Get bills in progress
$bills = $api->getBills('in-progress');
foreach ($bills['data']['bills'] as $bill) {
    echo "{$bill['bill_reference']}: {$bill['title']} ({$bill['status']})\n";
}

require 'net/http'
require 'json'
require 'uri'

class OpenParliamentAPI
  BASE_URL = 'https://open.hnsrd.ai/v1'

  def initialize(api_key, country)
    @api_key = api_key
    @country = country  # Required: ISO 3166-1 alpha-3 code
  end

  def get_sittings(page: 1, year: nil)
    params = { page: page }
    params[:year] = year if year
    request('/sittings', params)
  end

  def get_sitting(id)
    request("/sittings/#{id}")
  end

  def search_speeches(query, page: 1)
    request('/speeches/search', { q: query, page: page })
  end

  def get_members(page: 1, party: nil)
    params = { page: page }
    params[:party] = party if party
    request('/members', params)
  end

  def get_member_stats(id)
    request("/members/#{id}/stats")
  end

  def get_bills(status: nil)
    endpoint = status ? "/bills/#{status}" : '/bills'
    request(endpoint)
  end

  def search(query, type: 'all')
    request('/search', { q: query, type: type })
  end

  def get_stats
    request('/stats')
  end

  private

  def request(endpoint, params = {})
    params[:country] = @country  # Always include country
    uri = URI("#{BASE_URL}#{endpoint}")
    uri.query = URI.encode_www_form(params) unless params.empty?

    req = Net::HTTP::Get.new(uri)
    req['X-API-Key'] = @api_key

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(req)
    end

    data = JSON.parse(response.body)
    raise "API Error: #{data['error']['message']}" unless data['success']

    data
  end
end

# Usage - specify your authorized country code
api = OpenParliamentAPI.new('hnsrd_your_key', 'AIA')

# Get 2024 sittings
sittings = api.get_sittings(year: 2024)
puts "Found #{sittings['meta']['total']} sittings in 2024"

# Search speeches
results = api.search_speeches('education budget')
results['data']['results'].first(5).each do |speech|
  puts "#{speech['speaker_name']}: #{speech['text_preview'][0..80]}..."
end

# Get bills in progress
bills = api.get_bills(status: 'in-progress')
bills['data']['bills'].each do |bill|
  puts "#{bill['bill_reference']}: #{bill['title']} (#{bill['status']})"
end