#!/usr/bin/env python3
"""Complete Python client for the Economic Calendar API."""

from __future__ import annotations

import sys
from typing import Any, Dict, Optional

import requests

BASE_URL = "https://api.example.com"
API_KEY = "YOUR_API_KEY"
SUBSCRIPTION = "basic"  # free | basic | pro | ultra

HEADERS = {
    "X-Api-Key": API_KEY,
    "X-Subscription": SUBSCRIPTION,
    "Accept": "application/json",
}

class EconomicCalendarClient:
    def __init__(
        self,
        base_url: str = BASE_URL,
        headers: Optional[Dict[str, str]] = None,
        timeout: int = 30,
    ) -> None:
        self.base_url = base_url.rstrip("/")
        self.session = requests.Session()
        self.session.headers.update(headers or HEADERS)
        self.timeout = timeout

    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
        url = f"{self.base_url}{path}"
        response = self.session.get(url, params=params, timeout=self.timeout)
        if response.status_code >= 400:
            raise RuntimeError(
                f"HTTP {response.status_code}: {response.text[:500]}"
            )
        return response.json()

    def ping(self) -> Dict[str, Any]:
        return self.get("/ping")

    def langs_list(self) -> Any:
        return self.get("/langs-list")

    def countries_list(self, lang: str = "en") -> Any:
        return self.get("/countries-list", params={"lang": lang})

    def filter_events(self, **params: Any) -> Dict[str, Any]:
        return self.get("/economic-events/filter", params=params)

    def event_history(self, event_id: int, **params: Any) -> Dict[str, Any]:
        return self.get(f"/economic-events/{event_id}/history", params=params)

def main() -> int:
    client = EconomicCalendarClient()

    health = client.ping()
    print("ping:", health)

    page = client.filter_events(
        date="today",
        importance="high",
        lang="en",
    )
    print("meta:", page.get("meta"))
    for event in page.get("data", [])[:5]:
        print(
            event.get("occurrence_time"),
            event.get("currency"),
            event.get("short_name"),
            "actual=",
            event.get("actual"),
            "forecast=",
            event.get("forecast"),
        )
    return 0

if __name__ == "__main__":
    sys.exit(main())

/**
 * Complete Node.js / browser client for the Economic Calendar API.
 * Node 18+ (built-in fetch) or modern browsers.
 */

const BASE_URL = "https://api.example.com";
const API_KEY = "YOUR_API_KEY";
const SUBSCRIPTION = "basic"; // free | basic | pro | ultra

const HEADERS = {
  "X-Api-Key": API_KEY,
  "X-Subscription": SUBSCRIPTION,
  Accept: "application/json",
};

class EconomicCalendarClient {
  constructor(baseUrl = BASE_URL, headers = HEADERS) {
    this.baseUrl = baseUrl.replace(/\/$/, "");
    this.headers = headers;
  }

  async request(path, params = {}) {
    const url = new URL(`${this.baseUrl}${path}`);
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null && value !== "") {
        url.searchParams.set(key, String(value));
      }
    });

    const response = await fetch(url, {
      method: "GET",
      headers: this.headers,
    });

    const text = await response.text();
    let body;
    try {
      body = text ? JSON.parse(text) : null;
    } catch {
      body = text;
    }

    if (!response.ok) {
      throw new Error(
        `HTTP ${response.status}: ${typeof body === "string" ? body : JSON.stringify(body)}`
      );
    }
    return body;
  }

  ping() {
    return this.request("/ping");
  }

  langsList() {
    return this.request("/langs-list");
  }

  countriesList(lang = "en") {
    return this.request("/countries-list", { lang });
  }

  filterEvents(params = {}) {
    return this.request("/economic-events/filter", params);
  }

  eventHistory(eventId, params = {}) {
    return this.request(`/economic-events/${eventId}/history`, params);
  }
}

async function main() {
  const client = new EconomicCalendarClient();

  const health = await client.ping();
  console.log("ping:", health);

  const page = await client.filterEvents({
    date: "today",
    importance: "high",
    lang: "en",
  });

  console.log("meta:", page.meta);
  for (const event of (page.data || []).slice(0, 5)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
/**
 * Complete PHP client for the Economic Calendar API.
 */

declare(strict_types=1);

final class EconomicCalendarClient
{
    private string $baseUrl;
    /** @var array<int, string> */
    private array $headers;
    private int $timeout;

    public function __construct(
        string $baseUrl = 'https://api.example.com',
        string $apiKey = 'YOUR_API_KEY',
        string $subscription = 'basic',
        int $timeout = 30
    ) {
        $this->baseUrl = rtrim($baseUrl, '/');
        $this->timeout = $timeout;
        $this->headers = [
            'X-Api-Key: ' . $apiKey,
            'X-Subscription: ' . $subscription,
            'Accept: application/json',
        ];
    }

    /**
     * @param array<string, scalar|null> $params
     * @return array<mixed>
     */
    public function get(string $path, array $params = []): array
    {
        $query = http_build_query(array_filter(
            $params,
            static fn($v) => $v !== null && $v !== ''
        ));
        $url = $this->baseUrl . $path . ($query !== '' ? '?' . $query : '');

        $ch = curl_init($url);
        if ($ch === false) {
            throw new RuntimeException('Unable to init cURL');
        }

        curl_setopt_array($ch, [
            CURLOPT_HTTPHEADER => $this->headers,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => $this->timeout,
            CURLOPT_FOLLOWLOCATION => true,
        ]);

        $raw = curl_exec($ch);
        $errno = curl_errno($ch);
        $error = curl_error($ch);
        $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($errno !== 0) {
            throw new RuntimeException('cURL error: ' . $error, $errno);
        }

        $decoded = json_decode((string) $raw, true);
        if ($status >= 400) {
            $message = is_array($decoded) ? json_encode($decoded) : (string) $raw;
            throw new RuntimeException('HTTP ' . $status . ': ' . $message, $status);
        }

        if (!is_array($decoded)) {
            throw new RuntimeException('Invalid JSON response');
        }

        return $decoded;
    }

    public function ping(): array
    {
        return $this->get('/ping');
    }

    public function langsList(): array
    {
        return $this->get('/langs-list');
    }

    /** @return array<string, mixed> */
    public function countriesList(string $lang = 'en'): array
    {
        return $this->get('/countries-list', ['lang' => $lang]);
    }

    /** @param array<string, scalar|null> $params */
    public function filterEvents(array $params = []): array
    {
        return $this->get('/economic-events/filter', $params);
    }

    /** @param array<string, scalar|null> $params */
    public function eventHistory(int $eventId, array $params = []): array
    {
        return $this->get('/economic-events/' . $eventId . '/history', $params);
    }
}

$client = new EconomicCalendarClient();

$health = $client->ping();
echo "ping: " . json_encode($health, JSON_UNESCAPED_UNICODE) . PHP_EOL;

$page = $client->filterEvents([
    'date' => 'today',
    'importance' => 'high',
    'lang' => 'en',
]);

echo "meta: " . json_encode($page['meta'] ?? null, JSON_UNESCAPED_UNICODE) . PHP_EOL;

foreach (array_slice($page['data'] ?? [], 0, 5) as $event) {
    echo sprintf(
        "%s %s %s actual=%s forecast=%s
",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

const (
    baseURL      = "https://api.example.com"
    apiKey       = "YOUR_API_KEY"
    subscription = "basic" // free | basic | pro | ultra
)

type Client struct {
    BaseURL string
    HTTP    *http.Client
    APIKey  string
    Plan    string
}

func NewClient() *Client {
    return &Client{
        BaseURL: baseURL,
        HTTP:    &http.Client{Timeout: 30 * time.Second},
        APIKey:  apiKey,
        Plan:    subscription,
    }
}

func (c *Client) Get(path string, query url.Values) (map[string]any, error) {
    u, err := url.Parse(c.BaseURL + path)
    if err != nil {
        return nil, err
    }
    if query != nil {
        u.RawQuery = query.Encode()
    }

    req, err := http.NewRequest(http.MethodGet, u.String(), nil)
    if err != nil {
        return nil, err
    }
    req.Header.Set("X-Api-Key", c.APIKey)
    req.Header.Set("X-Subscription", c.Plan)
    req.Header.Set("Accept", "application/json")

    resp, err := c.HTTP.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    if resp.StatusCode >= 400 {
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
    }

    var out map[string]any
    if err := json.Unmarshal(body, &out); err != nil {
        return nil, err
    }
    return out, nil
}

func main() {
    client := NewClient()

    health, err := client.Get("/ping", nil)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    fmt.Println("ping:", health)

    q := url.Values{}
    q.Set("date", "today")
    q.Set("importance", "high")
    q.Set("lang", "en")

    page, err := client.Get("/economic-events/filter", q)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    fmt.Println("meta:", page["meta"])

    data, _ := page["data"].([]any)
    for i, item := range data {
        if i >= 5 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(
            event["occurrence_time"],
            event["currency"],
            event["short_name"],
            "actual=", event["actual"],
            "forecast=", event["forecast"],
        )
    }
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Complete Java 11+ client for the Economic Calendar API.
 */
public class EconomicCalendarClient {
    private static final String BASE_URL = "https://api.example.com";
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String SUBSCRIPTION = "basic"; // free | basic | pro | ultra

    private final HttpClient http = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(15))
            .build();

    public String get(String path, Map<String, String> params) throws Exception {
        String query = params.entrySet().stream()
                .filter(e -> e.getValue() != null && !e.getValue().isEmpty())
                .map(e -> encode(e.getKey()) + "=" + encode(e.getValue()))
                .collect(Collectors.joining("&"));

        String uri = BASE_URL + path + (query.isEmpty() ? "" : "?" + query);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(uri))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", API_KEY)
                .header("X-Subscription", SUBSCRIPTION)
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = http.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        return response.body();
    }

    private static String encode(String value) {
        return URLEncoder.encode(value, StandardCharsets.UTF_8);
    }

    public static void main(String[] args) throws Exception {
        EconomicCalendarClient client = new EconomicCalendarClient();

        System.out.println("ping: " + client.get("/ping", Map.of()));

        Map<String, String> params = new LinkedHashMap<>();
        params.put("date", "today");
        params.put("importance", "high");
        params.put("lang", "en");

        String body = client.get("/economic-events/filter", params);
        System.out.println(body);
    }
}

#!/usr/bin/env python3
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

response = requests.get(f"{BASE_URL}/", headers=HEADERS, timeout=30)
response.raise_for_status()
print(response.status_code, response.json())

const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/`, { headers: HEADERS });
  const body = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(body)}`);
  }
  console.log(body);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status >= 400) {
    throw new RuntimeException("HTTP {$status}: {$raw}");
}

echo $raw, PHP_EOL;

package main

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

func main() {
    client := &http.Client{Timeout: 30 * time.Second}
    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s
", resp.StatusCode, body)
        os.Exit(1)
    }
    fmt.Println(string(body))
}

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

public class RootExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(15))
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/"))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", "basic")
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        System.out.println(response.body());
    }
}

{"status":"ok"}

#!/usr/bin/env python3
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

response = requests.get(f"{BASE_URL}/ping", headers=HEADERS, timeout=30)
response.raise_for_status()
payload = response.json()
assert payload.get("status") == "ok", payload
print(payload)

const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/ping`, { headers: HEADERS });
  const body = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(body)}`);
  }
  if (body.status !== "ok") {
    throw new Error(`Unexpected payload: ${JSON.stringify(body)}`);
  }
  console.log(body); // { status: "ok" }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/ping');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400 || ($payload['status'] ?? null) !== 'ok') {
    throw new RuntimeException("Health check failed: HTTP {$status} {$raw}");
}

echo json_encode($payload, JSON_PRETTY_PRINT), PHP_EOL;

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    client := &http.Client{Timeout: 30 * time.Second}
    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/ping", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s
", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    if payload["status"] != "ok" {
        fmt.Fprintf(os.Stderr, "unexpected payload: %s
", body)
        os.Exit(1)
    }
    fmt.Println(string(body))
}

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

public class PingExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/ping"))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", "basic")
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        System.out.println(response.body()); // {"status":"ok"}
    }
}

{"status":"ok"}

#!/usr/bin/env python3
"""List supported language codes"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {}

response = requests.get(
    f"{BASE_URL}/langs-list",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

codes = [row.get("code") for row in payload]
print("count:", len(codes))
print("sample:", codes[:10])

/**
 * List supported language codes
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/langs-list`);
  // no query params

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  const codes = payload.map((row) => row.code);
  console.log("count:", codes.length);
  console.log("sample:", codes.slice(0, 10));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** List supported language codes */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([]);
$ch = curl_init($baseUrl . '/langs-list' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

$codes = array_column($payload, 'code');
echo 'count: ' . count($codes) . PHP_EOL;
echo 'sample: ' . implode(', ', array_slice($codes, 0, 10)) . PHP_EOL;

package main

// List supported language codes

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/langs-list", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** List supported language codes */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/langs-list"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

[
  {"code":"en","name":"English"},
  {"code":"tr","name":"Turkish"},
  {"code":"de","name":"German"},
  {"code":"jp","name":"Japanese"},
  {"code":"es","name":"Spanish"}
]

#!/usr/bin/env python3
"""Countries list in English"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/countries-list",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("United States:", payload.get("5"))
print("keys sample:", list(payload.keys())[:8])

/**
 * Countries list in English
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/countries-list`);
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("United States:", payload["5"]);
  console.log("keys sample:", Object.keys(payload).slice(0, 8));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Countries list in English */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/countries-list' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo 'United States: ' . json_encode($payload['5'] ?? null, JSON_UNESCAPED_UNICODE) . PHP_EOL;
echo 'keys sample: ' . implode(', ', array_slice(array_keys($payload), 0, 8)) . PHP_EOL;

package main

// Countries list in English

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/countries-list?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Countries list in English */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/countries-list?lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

{
  "5": {"name":"United States","flag":"United_States"},
  "4": {"name":"United Kingdom","flag":"United_Kingdom"},
  "72": {"name":"Euro Zone","flag":"Euro_Zone"},
  "17": {"name":"Germany","flag":"Germany"},
  "35": {"name":"Japan","flag":"Japan"}
}

#!/usr/bin/env python3
"""Countries list in German"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "lang": "de",
}

response = requests.get(
    f"{BASE_URL}/countries-list",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("United States:", payload.get("5"))
print("keys sample:", list(payload.keys())[:8])

/**
 * Countries list in German
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/countries-list`);
  url.searchParams.set("lang", "de");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("United States:", payload["5"]);
  console.log("keys sample:", Object.keys(payload).slice(0, 8));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Countries list in German */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'lang' => 'de',
]);
$ch = curl_init($baseUrl . '/countries-list' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo 'United States: ' . json_encode($payload['5'] ?? null, JSON_UNESCAPED_UNICODE) . PHP_EOL;
echo 'keys sample: ' . implode(', ', array_slice(array_keys($payload), 0, 8)) . PHP_EOL;

package main

// Countries list in German

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("lang", "de")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/countries-list?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Countries list in German */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/countries-list?lang=de"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Missing countries-list language (expect 404)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "lang": "xx",
}

response = requests.get(
    f"{BASE_URL}/countries-list",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("status:", response.status_code)
print(json.dumps(payload, indent=2, ensure_ascii=False))

/**
 * Missing countries-list language (expect 404)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/countries-list`);
  url.searchParams.set("lang", "xx");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("status:", response.status);
  console.log(JSON.stringify(payload, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Missing countries-list language (expect 404) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'lang' => 'xx',
]);
$ch = curl_init($baseUrl . '/countries-list' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Missing countries-list language (expect 404)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("lang", "xx")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/countries-list?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Missing countries-list language (expect 404) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/countries-list?lang=xx"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params={"date": "today", "lang": "en"},
    timeout=30,
)
response.raise_for_status()
payload = response.json()

print("meta:", json.dumps(payload.get("meta"), indent=2))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "today");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'today',
    'lang' => 'en',
]);

$ch = curl_init($baseUrl . '/economic-events/filter?' . $query);
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400 || !is_array($payload)) {
    throw new RuntimeException("HTTP {$status}: {$raw}");
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s
",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("lang", "en")

    req, err := http.NewRequest(
        http.MethodGet,
        "https://api.example.com/economic-events/filter?"+q.Encode(),
        nil,
    )
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s
", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])

    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(
            event["occurrence_time"], event["currency"], event["importance"],
            event["short_name"], "actual=", event["actual"], "forecast=", event["forecast"],
        )
    }
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class FilterTodayExample {
    public static void main(String[] args) throws Exception {
        Map<String, String> params = new LinkedHashMap<>();
        params.put("date", "today");
        params.put("lang", "en");

        String query = params.entrySet().stream()
                .map(e -> enc(e.getKey()) + "=" + enc(e.getValue()))
                .collect(Collectors.joining("&"));

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/economic-events/filter?" + query))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", "basic")
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        System.out.println(response.body());
    }

    private static String enc(String value) {
        return URLEncoder.encode(value, StandardCharsets.UTF_8);
    }
}

#!/usr/bin/env python3
"""B — Yesterday, high impact only"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "yesterday",
    "importance": "high",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * B — Yesterday, high impact only
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "yesterday");
  url.searchParams.set("importance", "high");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** B — Yesterday, high impact only */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'yesterday',
    'importance' => 'high',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// B — Yesterday, high impact only

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "yesterday")
    q.Set("importance", "high")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** B — Yesterday, high impact only */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=yesterday&importance=high&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""C — Current week for USD and EUR (medium + high)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "current_week",
    "currency": "USD,EUR",
    "importance": "high,medium",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * C — Current week for USD and EUR (medium + high)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "current_week");
  url.searchParams.set("currency", "USD,EUR");
  url.searchParams.set("importance", "high,medium");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** C — Current week for USD and EUR (medium + high) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'current_week',
    'currency' => 'USD,EUR',
    'importance' => 'high,medium',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// C — Current week for USD and EUR (medium + high)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("currency", "USD,EUR")
    q.Set("importance", "high,medium")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** C — Current week for USD and EUR (medium + high) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=current_week&currency=USD,EUR&importance=high,medium&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""D — Previous week, United States only"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "previous_week",
    "country_id": "5",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * D — Previous week, United States only
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "previous_week");
  url.searchParams.set("country_id", "5");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** D — Previous week, United States only */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'previous_week',
    'country_id' => '5',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// D — Previous week, United States only

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "previous_week")
    q.Set("country_id", "5")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** D — Previous week, United States only */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=previous_week&country_id=5&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""E — Next week, Euro Zone + Germany, high impact"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "next_week",
    "country_id": "72,17",
    "importance": "high",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * E — Next week, Euro Zone + Germany, high impact
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "next_week");
  url.searchParams.set("country_id", "72,17");
  url.searchParams.set("importance", "high");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** E — Next week, Euro Zone + Germany, high impact */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'next_week',
    'country_id' => '72,17',
    'importance' => 'high',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// E — Next week, Euro Zone + Germany, high impact

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "next_week")
    q.Set("country_id", "72,17")
    q.Set("importance", "high")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** E — Next week, Euro Zone + Germany, high impact */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=next_week&country_id=72,17&importance=high&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""F — Explicit month range (research archive)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "pro",
    "Accept": "application/json",
}

params = {
    "date_from": "2026-08-01",
    "date_to": "2026-08-31",
    "currency": "USD",
    "importance": "high",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * F — Explicit month range (research archive)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date_from", "2026-08-01");
  url.searchParams.set("date_to", "2026-08-31");
  url.searchParams.set("currency", "USD");
  url.searchParams.set("importance", "high");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** F — Explicit month range (research archive) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

$query = http_build_query([
    'date_from' => '2026-08-01',
    'date_to' => '2026-08-31',
    'currency' => 'USD',
    'importance' => 'high',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// F — Explicit month range (research archive)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-01")
    q.Set("date_to", "2026-08-31")
    q.Set("currency", "USD")
    q.Set("importance", "high")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "pro")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** F — Explicit month range (research archive) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date_from=2026-08-01&date_to=2026-08-31&currency=USD&importance=high&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "pro")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""G — Single day via `date=YYYY-MM-DD`"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "2026-08-19",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * G — Single day via `date=YYYY-MM-DD`
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "2026-08-19");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** G — Single day via `date=YYYY-MM-DD` */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => '2026-08-19',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// G — Single day via `date=YYYY-MM-DD`

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "2026-08-19")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** G — Single day via `date=YYYY-MM-DD` */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=2026-08-19&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""H — Multi-country basket (US, UK, Canada, Germany, Japan, Australia)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "current_week",
    "country_id": "5,4,6,17,35,25",
    "importance": "high,medium",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * H — Multi-country basket (US, UK, Canada, Germany, Japan, Australia)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "current_week");
  url.searchParams.set("country_id", "5,4,6,17,35,25");
  url.searchParams.set("importance", "high,medium");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** H — Multi-country basket (US, UK, Canada, Germany, Japan, Australia) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'current_week',
    'country_id' => '5,4,6,17,35,25',
    'importance' => 'high,medium',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// H — Multi-country basket (US, UK, Canada, Germany, Japan, Australia)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("country_id", "5,4,6,17,35,25")
    q.Set("importance", "high,medium")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** H — Multi-country basket (US, UK, Canada, Germany, Japan, Australia) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=current_week&country_id=5,4,6,17,35,25&importance=high,medium&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""I — Currency-only filter (JPY, three-day window)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date_from": "2026-08-18",
    "date_to": "2026-08-20",
    "currency": "JPY",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * I — Currency-only filter (JPY, three-day window)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date_from", "2026-08-18");
  url.searchParams.set("date_to", "2026-08-20");
  url.searchParams.set("currency", "JPY");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** I — Currency-only filter (JPY, three-day window) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date_from' => '2026-08-18',
    'date_to' => '2026-08-20',
    'currency' => 'JPY',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// I — Currency-only filter (JPY, three-day window)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-18")
    q.Set("date_to", "2026-08-20")
    q.Set("currency", "JPY")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** I — Currency-only filter (JPY, three-day window) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date_from=2026-08-18&date_to=2026-08-20&currency=JPY&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""J — Importance explicitly set to all"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "today",
    "importance": "all",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * J — Importance explicitly set to all
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "today");
  url.searchParams.set("importance", "all");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** J — Importance explicitly set to all */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'today',
    'importance' => 'all',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// J — Importance explicitly set to all

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("importance", "all")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** J — Importance explicitly set to all */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=today&importance=all&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""K — Non-English language (plan permitting)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "pro",
    "Accept": "application/json",
}

params = {
    "date": "today",
    "lang": "de",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * K — Non-English language (plan permitting)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "today");
  url.searchParams.set("lang", "de");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** K — Non-English language (plan permitting) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'today',
    'lang' => 'de',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// K — Non-English language (plan permitting)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("lang", "de")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "pro")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** K — Non-English language (plan permitting) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=today&lang=de"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "pro")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""L — Pro multi-language request (max 5 codes)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "pro",
    "Accept": "application/json",
}

params = {
    "date": "current_week",
    "currency": "EUR",
    "lang": "en,de,fr,it,es",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * L — Pro multi-language request (max 5 codes)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "current_week");
  url.searchParams.set("currency", "EUR");
  url.searchParams.set("lang", "en,de,fr,it,es");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** L — Pro multi-language request (max 5 codes) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'current_week',
    'currency' => 'EUR',
    'lang' => 'en,de,fr,it,es',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// L — Pro multi-language request (max 5 codes)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("currency", "EUR")
    q.Set("lang", "en,de,fr,it,es")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "pro")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** L — Pro multi-language request (max 5 codes) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=current_week&currency=EUR&lang=en,de,fr,it,es"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "pro")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""M — Language outside plan (expect 403)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "today",
    "lang": "de",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("status:", response.status_code)
print(json.dumps(payload, indent=2, ensure_ascii=False))

/**
 * M — Language outside plan (expect 403)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "today");
  url.searchParams.set("lang", "de");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("status:", response.status);
  console.log(JSON.stringify(payload, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** M — Language outside plan (expect 403) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'today',
    'lang' => 'de',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// M — Language outside plan (expect 403)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("lang", "de")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** M — Language outside plan (expect 403) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=today&lang=de"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

{"detail":"Your plan allows only English language"}

/**
 * Cursor pagination loop for /economic-events/filter.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

async function fetchAllHighImpact(from, to) {
  const rows = [];
  let cursor = null;

  while (true) {
    const url = new URL(`${BASE_URL}/economic-events/filter`);
    url.searchParams.set("date_from", from);
    url.searchParams.set("date_to", to);
    url.searchParams.set("importance", "high");
    url.searchParams.set("lang", "en");
    if (cursor) url.searchParams.set("cursor", cursor);

    const response = await fetch(url, { headers: HEADERS });
    const body = await response.json();
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${JSON.stringify(body)}`);
    }

    rows.push(...(body.data || []));
    cursor = body.meta?.next_cursor || null;
    if (!cursor) break;
  }

  return rows;
}

fetchAllHighImpact("2026-01-01", "2026-03-31")
  .then((rows) => console.log("total rows:", rows.length))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });

<?php
declare(strict_types=1);
/** Cursor pagination loop for /economic-events/filter. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

$params = [
    'date_from' => '2026-01-01',
    'date_to' => '2026-03-31',
    'importance' => 'high',
    'lang' => 'en',
];

$all = [];
$cursor = null;
do {
    if ($cursor) {
        $params['cursor'] = $cursor;
    }
    $ch = curl_init($baseUrl . '/economic-events/filter?' . http_build_query($params));
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $body = json_decode((string) $raw, true);
    if ($status >= 400 || !is_array($body)) {
        throw new RuntimeException("HTTP {$status}: {$raw}");
    }
    $all = array_merge($all, $body['data'] ?? []);
    $cursor = $body['meta']['next_cursor'] ?? null;
} while ($cursor);

echo 'total rows: ' . count($all) . PHP_EOL;

package main

// Cursor pagination loop for /economic-events/filter.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    headers := map[string]string{
        "X-Api-Key":      "YOUR_API_KEY",
        "X-Subscription": "pro",
        "Accept":         "application/json",
    }

    var all []any
    cursor := ""
    client := &http.Client{Timeout: 30 * time.Second}

    for {
        q := url.Values{}
        q.Set("date_from", "2026-01-01")
        q.Set("date_to", "2026-03-31")
        q.Set("importance", "high")
        q.Set("lang", "en")
        if cursor != "" {
            q.Set("cursor", cursor)
        }

        req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
        if err != nil {
            panic(err)
        }
        for k, v := range headers {
            req.Header.Set(k, v)
        }

        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        if resp.StatusCode >= 400 {
            fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
            os.Exit(1)
        }

        var payload map[string]any
        if err := json.Unmarshal(body, &payload); err != nil {
            panic(err)
        }
        if data, ok := payload["data"].([]any); ok {
            all = append(all, data...)
        }
        meta, _ := payload["meta"].(map[string]any)
        next, _ := meta["next_cursor"].(string)
        if next == "" {
            break
        }
        cursor = next
    }

    fmt.Println("total rows:", len(all))
}

#!/usr/bin/env bash
# Manual pagination with next_cursor (Pro example)
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"
SUBSCRIPTION="pro"
CURSOR=""

while true; do
  URL="${BASE_URL}/economic-events/filter?date_from=2026-01-01&date_to=2026-03-31&importance=high&lang=en"
  if [[ -n "${CURSOR}" ]]; then
    URL="${URL}&cursor=${CURSOR}"
  fi

  PAGE="$(curl -sS "${URL}" \
    -H "X-Api-Key: ${API_KEY}" \
    -H "X-Subscription: ${SUBSCRIPTION}" \
    -H "Accept: application/json")"

  echo "${PAGE}" | jq '{returned: .meta.returned, next_cursor: .meta.next_cursor, sample: .data[0:2]}'
  CURSOR="$(echo "${PAGE}" | jq -r '.meta.next_cursor // empty')"
  [[ -z "${CURSOR}" ]] && break
done

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** Cursor pagination loop for /economic-events/filter. */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        String cursor = null;
        int pages = 0;

        while (true) {
            StringBuilder q = new StringBuilder();
            q.append("date_from=2026-01-01&date_to=2026-03-31&importance=high&lang=en");
            if (cursor != null) {
                q.append("&cursor=").append(URLEncoder.encode(cursor, StandardCharsets.UTF_8));
            }

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/economic-events/filter?" + q))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", "pro")
                .header("Accept", "application/json")
                .GET()
                .build();

            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() >= 400) {
                System.err.println("HTTP " + response.statusCode() + ": " + response.body());
                System.exit(1);
            }

            pages++;
            String body = response.body();
            Matcher mCursor = Pattern.compile("\"next_cursor\"\\s*:\\s*\"([^\"]+)\"").matcher(body);
            if (mCursor.find()) {
                cursor = mCursor.group(1);
            } else {
                break;
            }
        }

        System.out.println("pages fetched: " + pages);
    }
}

#!/usr/bin/env python3
"""Combined major FX week query"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date_from": "2026-08-15",
    "date_to": "2026-08-22",
    "country_id": "5,4,72",
    "currency": "USD,EUR,GBP",
    "importance": "high",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * Combined major FX week query
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date_from", "2026-08-15");
  url.searchParams.set("date_to", "2026-08-22");
  url.searchParams.set("country_id", "5,4,72");
  url.searchParams.set("currency", "USD,EUR,GBP");
  url.searchParams.set("importance", "high");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Combined major FX week query */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date_from' => '2026-08-15',
    'date_to' => '2026-08-22',
    'country_id' => '5,4,72',
    'currency' => 'USD,EUR,GBP',
    'importance' => 'high',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// Combined major FX week query

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-15")
    q.Set("date_to", "2026-08-22")
    q.Set("country_id", "5,4,72")
    q.Set("currency", "USD,EUR,GBP")
    q.Set("importance", "high")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** Combined major FX week query */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date_from=2026-08-15&date_to=2026-08-22&country_id=5,4,72&currency=USD,EUR,GBP&importance=high&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Invalid date shortcut (expect 400)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "last_month",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("status:", response.status_code)
print(json.dumps(payload, indent=2, ensure_ascii=False))

/**
 * Invalid date shortcut (expect 400)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "last_month");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("status:", response.status);
  console.log(JSON.stringify(payload, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Invalid date shortcut (expect 400) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'last_month',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Invalid date shortcut (expect 400)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "last_month")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Invalid date shortcut (expect 400) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=last_month&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Invalid cursor (expect 400)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "today",
    "lang": "en",
    "cursor": "not-a-real-cursor",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("status:", response.status_code)
print(json.dumps(payload, indent=2, ensure_ascii=False))

/**
 * Invalid cursor (expect 400)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "today");
  url.searchParams.set("lang", "en");
  url.searchParams.set("cursor", "not-a-real-cursor");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("status:", response.status);
  console.log(JSON.stringify(payload, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Invalid cursor (expect 400) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'today',
    'lang' => 'en',
    'cursor' => 'not-a-real-cursor',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Invalid cursor (expect 400)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("lang", "en")
    q.Set("cursor", "not-a-real-cursor")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Invalid cursor (expect 400) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=today&lang=en&cursor=not-a-real-cursor"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Event history default sample"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "limit": 24,
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/1057/history",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

meta = payload.get("meta", {})
print(meta.get("short_name"), "returned=", meta.get("returned"))
for row in payload.get("data", [])[:10]:
    print(row.get("date"), "actual=", row.get("actual"), "forecast=", row.get("forecast"))

/**
 * Event history default sample
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/1057/history`);
  url.searchParams.set("limit", "24");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log(payload.meta.short_name, "returned=", payload.meta.returned);
  for (const row of (payload.data || []).slice(0, 10)) {
    console.log(row.date, "actual=", row.actual, "forecast=", row.forecast);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Event history default sample */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'limit' => 24,
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/1057/history' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

$meta = $payload['meta'] ?? [];
echo ($meta['short_name'] ?? '') . ' returned=' . ($meta['returned'] ?? 0) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $row) {
    echo ($row['date'] ?? '') . ' actual=' . ($row['actual'] ?? 'null')
        . ' forecast=' . ($row['forecast'] ?? 'null') . PHP_EOL;
}

package main

// Event history default sample

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("limit", "24")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/1057/history?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Event history default sample */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/1057/history?limit=24&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""History with released_only=true"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "limit": 24,
    "released_only": True,
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/1057/history",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

meta = payload.get("meta", {})
print(meta.get("short_name"), "returned=", meta.get("returned"))
for row in payload.get("data", [])[:10]:
    print(row.get("date"), "actual=", row.get("actual"), "forecast=", row.get("forecast"))

/**
 * History with released_only=true
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/1057/history`);
  url.searchParams.set("limit", "24");
  url.searchParams.set("released_only", "true");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log(payload.meta.short_name, "returned=", payload.meta.returned);
  for (const row of (payload.data || []).slice(0, 10)) {
    console.log(row.date, "actual=", row.actual, "forecast=", row.forecast);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** History with released_only=true */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'limit' => 24,
    'released_only' => true,
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/1057/history' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

$meta = $payload['meta'] ?? [];
echo ($meta['short_name'] ?? '') . ' returned=' . ($meta['returned'] ?? 0) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $row) {
    echo ($row['date'] ?? '') . ' actual=' . ($row['actual'] ?? 'null')
        . ' forecast=' . ($row['forecast'] ?? 'null') . PHP_EOL;
}

package main

// History with released_only=true

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("limit", "24")
    q.Set("released_only", "true")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/1057/history?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** History with released_only=true */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/1057/history?limit=24&released_only=true&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Free plan history cap"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "free",
    "Accept": "application/json",
}

params = {
    "limit": 100,
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/121/history",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

meta = payload.get("meta", {})
print(meta.get("short_name"), "returned=", meta.get("returned"))
for row in payload.get("data", [])[:10]:
    print(row.get("date"), "actual=", row.get("actual"), "forecast=", row.get("forecast"))

/**
 * Free plan history cap
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "free",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/121/history`);
  url.searchParams.set("limit", "100");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log(payload.meta.short_name, "returned=", payload.meta.returned);
  for (const row of (payload.data || []).slice(0, 10)) {
    console.log(row.date, "actual=", row.actual, "forecast=", row.forecast);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Free plan history cap */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: free',
    'Accept: application/json',
];

$query = http_build_query([
    'limit' => 100,
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/121/history' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

$meta = $payload['meta'] ?? [];
echo ($meta['short_name'] ?? '') . ' returned=' . ($meta['returned'] ?? 0) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $row) {
    echo ($row['date'] ?? '') . ' actual=' . ($row['actual'] ?? 'null')
        . ' forecast=' . ($row['forecast'] ?? 'null') . PHP_EOL;
}

package main

// Free plan history cap

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("limit", "100")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/121/history?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "free")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Free plan history cap */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/121/history?limit=100&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "free")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""Unknown event_id (expect 404)"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/999999999/history",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("status:", response.status_code)
print(json.dumps(payload, indent=2, ensure_ascii=False))

/**
 * Unknown event_id (expect 404)
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/999999999/history`);
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("status:", response.status);
  console.log(JSON.stringify(payload, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Unknown event_id (expect 404) */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/999999999/history' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Unknown event_id (expect 404)

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/999999999/history?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** Unknown event_id (expect 404) */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/999999999/history?lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

/**
 * Workflow: filter high-impact USD events, then fetch release history.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const filterUrl = new URL(`${BASE_URL}/economic-events/filter`);
  filterUrl.searchParams.set("date", "yesterday");
  filterUrl.searchParams.set("importance", "high");
  filterUrl.searchParams.set("currency", "USD");
  filterUrl.searchParams.set("lang", "en");

  const filterRes = await fetch(filterUrl, { headers: HEADERS });
  const filterPayload = await filterRes.json();
  if (!filterRes.ok) {
    throw new Error(`Filter HTTP ${filterRes.status}: ${JSON.stringify(filterPayload)}`);
  }
  if (!filterPayload.data?.length) {
    throw new Error("No events found for yesterday high-impact USD");
  }

  const eventId = filterPayload.data[0].event_id;
  const histUrl = new URL(`${BASE_URL}/economic-events/${eventId}/history`);
  histUrl.searchParams.set("released_only", "true");
  histUrl.searchParams.set("limit", "24");
  histUrl.searchParams.set("lang", "en");

  const histRes = await fetch(histUrl, { headers: HEADERS });
  const history = await histRes.json();
  if (!histRes.ok) {
    throw new Error(`History HTTP ${histRes.status}: ${JSON.stringify(history)}`);
  }

  console.log("event_id:", eventId);
  console.log("series:", history.meta?.short_name);
  console.log(history.data?.slice(0, 5));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Workflow: filter high-impact USD events, then fetch release history. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

function apiGet(string $url, array $headers): array {
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    $payload = json_decode((string) $raw, true);
    if ($status >= 400 || !is_array($payload)) {
        throw new RuntimeException("HTTP {$status}: {$raw}");
    }
    return $payload;
}

$filter = apiGet(
    $baseUrl . '/economic-events/filter?' . http_build_query([
        'date' => 'yesterday',
        'importance' => 'high',
        'currency' => 'USD',
        'lang' => 'en',
    ]),
    $headers
);
if (empty($filter['data'][0]['event_id'])) {
    throw new RuntimeException('No events found for yesterday high-impact USD');
}

$eventId = (int) $filter['data'][0]['event_id'];
$history = apiGet(
    $baseUrl . '/economic-events/' . $eventId . '/history?' . http_build_query([
        'released_only' => 'true',
        'limit' => 24,
        'lang' => 'en',
    ]),
    $headers
);

echo 'event_id: ' . $eventId . PHP_EOL;
echo 'series: ' . ($history['meta']['short_name'] ?? '') . PHP_EOL;
echo json_encode(array_slice($history['data'] ?? [], 0, 5), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Workflow: filter high-impact USD events, then fetch release history.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func getJSON(client *http.Client, rawURL string) map[string]any {
    req, err := http.NewRequest(http.MethodGet, rawURL, nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }
    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    return payload
}

func main() {
    client := &http.Client{Timeout: 30 * time.Second}

    fq := url.Values{}
    fq.Set("date", "yesterday")
    fq.Set("importance", "high")
    fq.Set("currency", "USD")
    fq.Set("lang", "en")
    filt := getJSON(client, "https://api.example.com/economic-events/filter?"+fq.Encode())

    data, _ := filt["data"].([]any)
    if len(data) == 0 {
        panic("No events found")
    }
    first, _ := data[0].(map[string]any)
    eventID := fmt.Sprint(first["event_id"])

    hq := url.Values{}
    hq.Set("released_only", "true")
    hq.Set("limit", "24")
    hq.Set("lang", "en")
    hist := getJSON(client, "https://api.example.com/economic-events/"+eventID+"/history?"+hq.Encode())

    meta, _ := hist["meta"].(map[string]any)
    fmt.Println("event_id:", eventID)
    fmt.Println("series:", meta["short_name"])
    fmt.Println(hist["data"])
}

#!/usr/bin/env bash
# Workflow: filter yesterday high-impact USD, then history for first event_id
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"
SUBSCRIPTION="basic"

FILTER="$(curl -sS "${BASE_URL}/economic-events/filter?date=yesterday&importance=high&currency=USD&lang=en" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: ${SUBSCRIPTION}" \
  -H "Accept: application/json")"

EVENT_ID="$(echo "${FILTER}" | jq -r '.data[0].event_id')"
echo "event_id=${EVENT_ID}"

curl -sS "${BASE_URL}/economic-events/${EVENT_ID}/history?released_only=true&limit=24&lang=en" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: ${SUBSCRIPTION}" \
  -H "Accept: application/json" | jq '{meta, sample: .data[0:5]}'

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** Workflow: filter high-impact USD events, then fetch release history. */
public class Example {
    private static String get(HttpClient client, String uri) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(uri))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        String filterBody = get(
            client,
            "https://api.example.com/economic-events/filter?date=yesterday&importance=high&currency=USD&lang=en"
        );
        Matcher m = Pattern.compile("\"event_id\"\\s*:\\s*(\\d+)").matcher(filterBody);
        if (!m.find()) {
            throw new IllegalStateException("No event_id found in filter response");
        }
        String eventId = m.group(1);

        String historyBody = get(
            client,
            "https://api.example.com/economic-events/" + eventId
                + "/history?released_only=true&limit=24&lang=en"
        );
        System.out.println("event_id: " + eventId);
        System.out.println(historyBody);
    }
}

#!/usr/bin/env python3
"""Start Ultra export job"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "ultra",
    "Accept": "application/json",
}

response = requests.post(f"{BASE_URL}/economic-events/export", headers=HEADERS, timeout=30)
print("status:", response.status_code)
print(json.dumps(response.json(), indent=2, ensure_ascii=False))

/**
 * Start Ultra export job
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "ultra",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/economic-events/export`, {
    method: "POST",
    headers: HEADERS,
  });
  const payload = await response.json();
  console.log("status:", response.status);
  console.log(payload);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Start Ultra export job */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: ultra',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/economic-events/export');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Start Ultra export job

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

func main() {
    req, err := http.NewRequest(http.MethodPost, "https://api.example.com/economic-events/export", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "ultra")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

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

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

/** Start Ultra export job */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/export"))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "ultra")
            .header("Accept", "application/json")
            .POST(HttpRequest.BodyPublishers.noBody())
            .build();

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

{
  "job_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "started"
}

#!/usr/bin/env python3
"""NDJSON stream for a date range"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "ultra",
    "Accept": "application/x-ndjson",
}

params = {
    "date_from": "2026-08-01",
    "date_to": "2026-08-07",
}

with requests.get(
    f"{BASE_URL}/economic-events/stream",
    headers=HEADERS,
    params=params,
    stream=True,
    timeout=120,
) as response:
    response.raise_for_status()
    for line in response.iter_lines(decode_unicode=True):
        if not line:
            continue
        event = json.loads(line)
        print(json.dumps(event, ensure_ascii=False))

/**
 * NDJSON stream for a date range
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "ultra",
  Accept: "application/x-ndjson",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/stream`);
  url.searchParams.set("date_from", "2026-08-01");
  url.searchParams.set("date_to", "2026-08-07");

  const response = await fetch(url, { headers: HEADERS });
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  const text = await response.text();
  for (const line of text.split("\n").filter(Boolean)) {
    console.log(JSON.parse(line));
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** NDJSON stream for a date range */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: ultra',
    'Accept: application/x-ndjson',
];

$query = http_build_query([
    'date_from' => '2026-08-01',
    'date_to' => '2026-08-07',
]);
$ch = curl_init($baseUrl . '/economic-events/stream?' . $query);
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 120,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status >= 400) {
    throw new RuntimeException("HTTP {$status}: {$raw}");
}

foreach (preg_split('/\r?\n/', (string) $raw) as $line) {
    $line = trim($line);
    if ($line === '') {
        continue;
    }
    $event = json_decode($line, true);
    echo json_encode($event, JSON_UNESCAPED_UNICODE) . PHP_EOL;
}

package main

// NDJSON stream for a date range

import (
    "bufio"
    "fmt"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-01")
    q.Set("date_to", "2026-08-07")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/stream?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "ultra")
    req.Header.Set("Accept", "application/x-ndjson")

    client := &http.Client{Timeout: 120 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d\n", resp.StatusCode)
        os.Exit(1)
    }

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if line != "" {
            fmt.Println(line)
        }
    }
}

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

/** NDJSON stream for a date range */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/stream?date_from=2026-08-01&date_to=2026-08-07"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "ultra")
            .header("Accept", "application/x-ndjson")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""HTML calendar redirect"""

import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "Accept": "application/json",
}

response = requests.get(
    f"{BASE_URL}/calendar",
    headers=HEADERS,
    allow_redirects=False,
    timeout=30,
)
print("status:", response.status_code)
print("location:", response.headers.get("Location"))

/**
 * HTML calendar redirect
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/calendar`, {
    headers: HEADERS,
    redirect: "manual",
  });
  console.log("status:", response.status);
  console.log("location:", response.headers.get("Location"));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** HTML calendar redirect */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/calendar');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADER => true,
    CURLOPT_NOBODY => true,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "status: {$status}" . PHP_EOL;
if (preg_match('/^Location:\s*(.+)$/mi', (string) $raw, $m)) {
    echo "location: " . trim($m[1]) . PHP_EOL;
}

package main

// HTML calendar redirect

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/calendar", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** HTML calendar redirect */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/calendar"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

/**
 * Typed error handling for /economic-events/filter.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function getFilter(params) {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  Object.entries(params).forEach(([key, value]) => url.searchParams.set(key, String(value)));

  const response = await fetch(url, { headers: HEADERS });
  const body = await response.json();
  if (!response.ok) {
    const detail = body.detail || response.statusText;
    const error = new Error(detail);
    error.status = response.status;
    throw error;
  }
  return body;
}

getFilter({ date: "today", lang: "en" })
  .then((body) => console.log("returned:", body.meta?.returned))
  .catch((err) => {
    console.error("client error:", err.status, err.message);
    process.exit(1);
  });

<?php
declare(strict_types=1);
/** Typed error handling for /economic-events/filter. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

function getFilter(string $baseUrl, array $headers, array $params): array {
    $ch = curl_init($baseUrl . '/economic-events/filter?' . http_build_query($params));
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
    ]);
    $raw = curl_exec($ch);
    $code = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $body = json_decode((string) $raw, true);
    if ($code >= 400) {
        $detail = is_array($body) ? ($body['detail'] ?? "HTTP {$code}") : "HTTP {$code}";
        throw new RuntimeException($detail, $code);
    }
    return is_array($body) ? $body : [];
}

try {
    $payload = getFilter($baseUrl, $headers, ['date' => 'today', 'lang' => 'en']);
    echo 'returned: ' . ($payload['meta']['returned'] ?? 0) . PHP_EOL;
} catch (RuntimeException $e) {
    fwrite(STDERR, 'client error: ' . $e->getMessage() . PHP_EOL);
    exit(1);
}

package main

// Typed error handling for /economic-events/filter.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func getFilter(params url.Values) (map[string]any, error) {
    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+params.Encode(), nil)
    if err != nil {
        return nil, err
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var payload map[string]any
    _ = json.Unmarshal(body, &payload)
    if resp.StatusCode >= 400 {
        detail, _ := payload["detail"].(string)
        if detail == "" {
            detail = string(body)
        }
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, detail)
    }
    return payload, nil
}

func main() {
    q := url.Values{}
    q.Set("date", "today")
    q.Set("lang", "en")
    payload, err := getFilter(q)
    if err != nil {
        fmt.Fprintln(os.Stderr, "client error:", err)
        os.Exit(1)
    }
    meta, _ := payload["meta"].(map[string]any)
    fmt.Println("returned:", meta["returned"])
}

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

/** Typed error handling for /economic-events/filter. */
public class Example {
    public static String getFilter(String query) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?" + query))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        try {
            String body = getFilter("date=today&lang=en");
            System.out.println(body);
        } catch (IllegalStateException ex) {
            System.err.println("client error: " + ex.getMessage());
            System.exit(1);
        }
    }
}

#!/usr/bin/env ruby
# Typed error handling for /economic-events/filter.

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

BASE_URL = "https://api.example.com"

def get_filter(params)
  uri = URI("#{BASE_URL}/economic-events/filter")
  uri.query = URI.encode_www_form(params)
  req = Net::HTTP::Get.new(uri)
  req["X-Api-Key"] = "YOUR_API_KEY"
  req["X-Subscription"] = "basic"
  req["Accept"] = "application/json"

  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
  body = JSON.parse(res.body)
  raise body["detail"] || "HTTP #{res.code}" unless res.is_a?(Net::HTTPSuccess)
  body
end

begin
  payload = get_filter("date" => "today", "lang" => "en")
  puts "returned: #{payload.dig("meta", "returned")}"
rescue StandardError => e
  warn "client error: #{e.message}"
  exit 1
end

using System;
using System.Net.Http;
using System.Threading.Tasks;

/// Typed error handling for /economic-events/filter.
public class Example
{
    private static readonly HttpClient Client = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(30)
    };

    public static async Task<string> GetFilterAsync(string query)
    {
        using var request = new HttpRequestMessage(
            HttpMethod.Get,
            $"https://api.example.com/economic-events/filter?{query}");
        request.Headers.Add("X-Api-Key", "YOUR_API_KEY");
        request.Headers.Add("X-Subscription", "basic");
        request.Headers.Add("Accept", "application/json");

        using var response = await Client.SendAsync(request);
        var body = await response.Content.ReadAsStringAsync();
        if (!response.IsSuccessStatusCode)
        {
            throw new InvalidOperationException($"HTTP {(int)response.StatusCode}: {body}");
        }
        return body;
    }

    public static async Task Main()
    {
        try
        {
            var json = await GetFilterAsync("date=today&lang=en");
            Console.WriteLine(json);
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"client error: {ex.Message}");
            Environment.Exit(1);
        }
    }
}

/**
 * Local surprise helpers for actual vs forecast.
 */
function surprise(actual, forecast) {
  if (actual == null || forecast == null) return null;
  return actual - forecast;
}

function surprisePct(actual, forecast) {
  const delta = surprise(actual, forecast);
  if (delta == null || forecast === 0) return null;
  return (100 * delta) / Math.abs(forecast);
}

console.log(surprise(7.5, 7.2));
console.log(surprisePct(7.5, 7.2));

<?php
declare(strict_types=1);
/** Local surprise helpers for actual vs forecast. */

function surprise($actual, $forecast) {
    if ($actual === null || $forecast === null) {
        return null;
    }
    return $actual - $forecast;
}

function surprise_pct($actual, $forecast) {
    $delta = surprise($actual, $forecast);
    if ($delta === null || (float) $forecast === 0.0) {
        return null;
    }
    return 100.0 * $delta / abs((float) $forecast);
}

echo surprise(7.5, 7.2) . PHP_EOL;
echo surprise_pct(7.5, 7.2) . PHP_EOL;

package main

import "fmt"

func surprise(actual, forecast *float64) *float64 {
    if actual == nil || forecast == nil {
        return nil
    }
    v := *actual - *forecast
    return &v
}

func main() {
    a, f := 7.5, 7.2
    fmt.Println(*surprise(&a, &f))
}

public class Example {
    public static Double surprise(Double actual, Double forecast) {
        if (actual == null || forecast == null) return null;
        return actual - forecast;
    }

    public static void main(String[] args) {
        System.out.println(surprise(7.5, 7.2));
    }
}

#!/usr/bin/env python3
"""Low importance only"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "current_week",
    "importance": "low",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * Low importance only
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "current_week");
  url.searchParams.set("importance", "low");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Low importance only */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'current_week',
    'importance' => 'low',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// Low importance only

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("importance", "low")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** Low importance only */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=current_week&importance=low&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""USD medium+high current week"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date": "current_week",
    "currency": "USD",
    "importance": "high,medium",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * USD medium+high current week
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date", "current_week");
  url.searchParams.set("currency", "USD");
  url.searchParams.set("importance", "high,medium");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** USD medium+high current week */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date' => 'current_week',
    'currency' => 'USD',
    'importance' => 'high,medium',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// USD medium+high current week

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("currency", "USD")
    q.Set("importance", "high,medium")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** USD medium+high current week */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date=current_week&currency=USD&importance=high,medium&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""US high-impact around CPI window"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "basic",
    "Accept": "application/json",
}

params = {
    "date_from": "2026-08-12",
    "date_to": "2026-08-14",
    "country_id": "5",
    "importance": "high",
    "lang": "en",
}

response = requests.get(
    f"{BASE_URL}/economic-events/filter",
    headers=HEADERS,
    params=params,
    timeout=30,
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
    print("status:", response.status_code)
    print(json.dumps(payload, indent=2, ensure_ascii=False))
    raise SystemExit(1)

print("meta:", json.dumps(payload.get("meta"), indent=2, ensure_ascii=False))
for event in payload.get("data", [])[:10]:
    print(
        f"{event.get('occurrence_time')} | {event.get('currency')} | "
        f"{event.get('importance')} | {event.get('short_name')} | "
        f"actual={event.get('actual')} forecast={event.get('forecast')}"
    )

/**
 * US high-impact around CPI window
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/filter`);
  url.searchParams.set("date_from", "2026-08-12");
  url.searchParams.set("date_to", "2026-08-14");
  url.searchParams.set("country_id", "5");
  url.searchParams.set("importance", "high");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }

  console.log("meta:", payload.meta);
  for (const event of (payload.data || []).slice(0, 10)) {
    console.log(
      event.occurrence_time,
      event.currency,
      event.importance,
      event.short_name,
      "actual=",
      event.actual,
      "forecast=",
      event.forecast
    );
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** US high-impact around CPI window */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$query = http_build_query([
    'date_from' => '2026-08-12',
    'date_to' => '2026-08-14',
    'country_id' => '5',
    'importance' => 'high',
    'lang' => 'en',
]);
$ch = curl_init($baseUrl . '/economic-events/filter' . ($query !== '' ? '?' . $query : ''));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
if ($status >= 400) {
    fwrite(STDERR, "HTTP {$status}: {$raw}\n");
    exit(1);
}

echo "meta: " . json_encode($payload['meta'] ?? null, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;
foreach (array_slice($payload['data'] ?? [], 0, 10) as $event) {
    echo sprintf(
        "%s | %s | %s | %s | actual=%s forecast=%s\n",
        $event['occurrence_time'] ?? '',
        $event['currency'] ?? '',
        $event['importance'] ?? '',
        $event['short_name'] ?? '',
        $event['actual'] ?? 'null',
        $event['forecast'] ?? 'null'
    );
}

package main

// US high-impact around CPI window

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-12")
    q.Set("date_to", "2026-08-14")
    q.Set("country_id", "5")
    q.Set("importance", "high")
    q.Set("lang", "en")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    fmt.Println("meta:", payload["meta"])
    data, _ := payload["data"].([]any)
    for i, item := range data {
        if i >= 10 {
            break
        }
        event, _ := item.(map[string]any)
        fmt.Println(event["occurrence_time"], event["currency"], event["importance"], event["short_name"])
    }
}

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

/** US high-impact around CPI window */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/filter?date_from=2026-08-12&date_to=2026-08-14&country_id=5&importance=high&lang=en"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

/**
 * Build a simple weekly calendar module from the Economic Calendar API.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

async function getJson(url) {
  const response = await fetch(url, { headers: HEADERS });
  const payload = await response.json();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(payload)}`);
  }
  return payload;
}

async function main() {
  // Step 1 — Load metadata
  const langs = await getJson(`${BASE_URL}/langs-list`);
  const countriesUrl = new URL(`${BASE_URL}/countries-list`);
  countriesUrl.searchParams.set("lang", "en");
  const countries = await getJson(countriesUrl);
  console.log("languages:", langs.length, "countries:", Object.keys(countries).length);

  // Step 2 — Fetch the week
  const weekUrl = new URL(`${BASE_URL}/economic-events/filter`);
  weekUrl.searchParams.set("date", "current_week");
  weekUrl.searchParams.set("country_id", "5,4,72,17,35");
  weekUrl.searchParams.set("importance", "high,medium");
  weekUrl.searchParams.set("lang", "en");
  const week = await getJson(weekUrl);

  // Step 3 — Group by calendar day
  const byDay = {};
  for (const row of week.data || []) {
    const day = String(row.occurrence_time).slice(0, 10);
    (byDay[day] ||= []).push(row);
  }
  Object.keys(byDay)
    .sort()
    .forEach((day) => console.log(day, byDay[day].length));

  // Step 4 — Attach history for high-impact cards
  for (const row of week.data || []) {
    if (row.importance !== "high") continue;
    const histUrl = new URL(`${BASE_URL}/economic-events/${row.event_id}/history`);
    histUrl.searchParams.set("released_only", "true");
    histUrl.searchParams.set("limit", "12");
    histUrl.searchParams.set("lang", "en");
    const hist = await getJson(histUrl);
    row._history = hist.data || [];
    console.log(row.short_name, "history points:", row._history.length);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Build a simple weekly calendar module from the Economic Calendar API. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

function apiGet(string $url, array $headers): array {
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    $payload = json_decode((string) $raw, true);
    if ($status >= 400 || !is_array($payload)) {
        throw new RuntimeException("HTTP {$status}: {$raw}");
    }
    return $payload;
}

// Step 1 — Load metadata
$langs = apiGet($baseUrl . '/langs-list', $headers);
$countries = apiGet($baseUrl . '/countries-list?lang=en', $headers);
echo 'languages: ' . count($langs) . ' countries: ' . count($countries) . PHP_EOL;

// Step 2 — Fetch the week
$week = apiGet($baseUrl . '/economic-events/filter?' . http_build_query([
    'date' => 'current_week',
    'country_id' => '5,4,72,17,35',
    'importance' => 'high,medium',
    'lang' => 'en',
]), $headers);

// Step 3 — Group by calendar day
$byDay = [];
foreach ($week['data'] ?? [] as $row) {
    $day = substr((string) ($row['occurrence_time'] ?? ''), 0, 10);
    $byDay[$day][] = $row;
}
ksort($byDay);
foreach ($byDay as $day => $rows) {
    echo $day . ' ' . count($rows) . PHP_EOL;
}

// Step 4 — Attach history for high-impact cards
foreach ($week['data'] ?? [] as &$row) {
    if (($row['importance'] ?? '') !== 'high') {
        continue;
    }
    $hist = apiGet($baseUrl . '/economic-events/' . $row['event_id'] . '/history?' . http_build_query([
        'released_only' => 'true',
        'limit' => 12,
        'lang' => 'en',
    ]), $headers);
    $row['_history'] = $hist['data'] ?? [];
    echo ($row['short_name'] ?? '') . ' history points: ' . count($row['_history']) . PHP_EOL;
}
unset($row);

package main

// Build a simple weekly calendar module from the Economic Calendar API.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "sort"
    "strings"
    "time"
)

func getJSON(client *http.Client, rawURL string) map[string]any {
    req, err := http.NewRequest(http.MethodGet, rawURL, nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "pro")
    req.Header.Set("Accept", "application/json")
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }
    var payload map[string]any
    if err := json.Unmarshal(body, &payload); err != nil {
        // langs-list returns an array
        var arr []any
        if err2 := json.Unmarshal(body, &arr); err2 == nil {
            return map[string]any{"_array": arr}
        }
        panic(err)
    }
    return payload
}

func main() {
    client := &http.Client{Timeout: 30 * time.Second}

    langs := getJSON(client, "https://api.example.com/langs-list")
    countries := getJSON(client, "https://api.example.com/countries-list?lang=en")
    fmt.Println("metadata loaded", langs != nil, len(countries))

    q := url.Values{}
    q.Set("date", "current_week")
    q.Set("country_id", "5,4,72,17,35")
    q.Set("importance", "high,medium")
    q.Set("lang", "en")
    week := getJSON(client, "https://api.example.com/economic-events/filter?"+q.Encode())

    byDay := map[string]int{}
    data, _ := week["data"].([]any)
    for _, item := range data {
        row, _ := item.(map[string]any)
        day := strings.Split(fmt.Sprint(row["occurrence_time"]), "T")[0]
        byDay[day]++
    }
    days := make([]string, 0, len(byDay))
    for d := range byDay {
        days = append(days, d)
    }
    sort.Strings(days)
    for _, d := range days {
        fmt.Println(d, byDay[d])
    }
}

#!/usr/bin/env bash
# Weekly calendar module: metadata + current_week basket
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"
SUBSCRIPTION="pro"

curl -sS "${BASE_URL}/langs-list" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: ${SUBSCRIPTION}" | jq 'length'

curl -sS "${BASE_URL}/countries-list?lang=en" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: ${SUBSCRIPTION}" | jq 'keys | length'

WEEK="$(curl -sS "${BASE_URL}/economic-events/filter?date=current_week&country_id=5,4,72,17,35&importance=high,medium&lang=en" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: ${SUBSCRIPTION}" \
  -H "Accept: application/json")"

echo "${WEEK}" | jq '[.data[] | .occurrence_time[0:10]] | group_by(.) | map({day: .[0], count: length})'

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

/** Build a simple weekly calendar module from the Economic Calendar API. */
public class Example {
    private static String get(HttpClient client, String uri) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(uri))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "pro")
            .header("Accept", "application/json")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": " + response.body());
        }
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        System.out.println(get(client, "https://api.example.com/langs-list"));
        System.out.println(get(client, "https://api.example.com/countries-list?lang=en"));
        System.out.println(get(
            client,
            "https://api.example.com/economic-events/filter"
                + "?date=current_week&country_id=5,4,72,17,35&importance=high,medium&lang=en"
        ));
    }
}

/**
 * Paginate high-impact events and export a CSV string.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "pro",
  Accept: "application/json",
};

const FIELDS = [
  "occurrence_id", "event_id", "occurrence_time", "short_name",
  "country_name", "currency", "importance", "actual", "forecast", "previous",
];

function csvEscape(value) {
  const text = value == null ? "" : String(value);
  if (/[",\n]/.test(text)) return `"${text.replace(/"/g, '""')}"`;
  return text;
}

async function fetchAll() {
  const rows = [];
  let cursor = null;
  while (true) {
    const url = new URL(`${BASE_URL}/economic-events/filter`);
    url.searchParams.set("date_from", "2026-01-01");
    url.searchParams.set("date_to", "2026-06-30");
    url.searchParams.set("importance", "high");
    url.searchParams.set("lang", "en");
    if (cursor) url.searchParams.set("cursor", cursor);

    const response = await fetch(url, { headers: HEADERS });
    const body = await response.json();
    if (!response.ok) throw new Error(JSON.stringify(body));
    rows.push(...(body.data || []));
    cursor = body.meta?.next_cursor || null;
    if (!cursor) break;
  }
  return rows;
}

async function main() {
  const rows = await fetchAll();
  const lines = [FIELDS.join(",")];
  for (const row of rows) {
    lines.push(FIELDS.map((field) => csvEscape(row[field])).join(","));
  }
  const csv = lines.join("\n");
  console.log(csv.slice(0, 500));
  console.log("total rows:", rows.length);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Paginate high-impact events and export a stable CSV. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: pro',
    'Accept: application/json',
];

$params = [
    'date_from' => '2026-01-01',
    'date_to' => '2026-06-30',
    'importance' => 'high',
    'lang' => 'en',
];

$rows = [];
$cursor = null;
do {
    if ($cursor) {
        $params['cursor'] = $cursor;
    }
    $ch = curl_init($baseUrl . '/economic-events/filter?' . http_build_query($params));
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 60,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    $body = json_decode((string) $raw, true);
    if ($status >= 400 || !is_array($body)) {
        throw new RuntimeException("HTTP {$status}: {$raw}");
    }
    $rows = array_merge($rows, $body['data'] ?? []);
    $cursor = $body['meta']['next_cursor'] ?? null;
} while ($cursor);

$fp = fopen('events.csv', 'w');
$fields = [
    'occurrence_id', 'event_id', 'occurrence_time', 'short_name',
    'country_name', 'currency', 'importance', 'actual', 'forecast', 'previous',
];
fputcsv($fp, $fields);
foreach ($rows as $row) {
    $line = [];
    foreach ($fields as $field) {
        $line[] = $row[$field] ?? null;
    }
    fputcsv($fp, $line);
}
fclose($fp);
echo 'wrote ' . count($rows) . " rows to events.csv\n";

package main

// Paginate high-impact events (CSV write left to your app).

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    client := &http.Client{Timeout: 60 * time.Second}
    cursor := ""
    total := 0

    for {
        q := url.Values{}
        q.Set("date_from", "2026-01-01")
        q.Set("date_to", "2026-06-30")
        q.Set("importance", "high")
        q.Set("lang", "en")
        if cursor != "" {
            q.Set("cursor", cursor)
        }

        req, _ := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/filter?"+q.Encode(), nil)
        req.Header.Set("X-Api-Key", "YOUR_API_KEY")
        req.Header.Set("X-Subscription", "pro")
        req.Header.Set("Accept", "application/json")

        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        if resp.StatusCode >= 400 {
            fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
            os.Exit(1)
        }

        var payload map[string]any
        _ = json.Unmarshal(body, &payload)
        if data, ok := payload["data"].([]any); ok {
            total += len(data)
        }
        meta, _ := payload["meta"].(map[string]any)
        next, _ := meta["next_cursor"].(string)
        if next == "" {
            break
        }
        cursor = next
    }

    fmt.Println("total rows:", total)
}

#!/usr/bin/env bash
# Paginate and append JSON lines (convert to CSV with jq/miller as needed)
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"
SUBSCRIPTION="pro"
CURSOR=""
: > events.ndjson

while true; do
  URL="${BASE_URL}/economic-events/filter?date_from=2026-01-01&date_to=2026-06-30&importance=high&lang=en"
  [[ -n "${CURSOR}" ]] && URL="${URL}&cursor=${CURSOR}"
  PAGE="$(curl -sS "${URL}" \
    -H "X-Api-Key: ${API_KEY}" \
    -H "X-Subscription: ${SUBSCRIPTION}" \
    -H "Accept: application/json")"
  echo "${PAGE}" | jq -c '.data[]' >> events.ndjson
  CURSOR="$(echo "${PAGE}" | jq -r '.meta.next_cursor // empty')"
  [[ -z "${CURSOR}" ]] && break
done

wc -l events.ndjson

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** Paginate high-impact events for CSV/warehouse export. */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        String cursor = null;
        int pages = 0;
        while (true) {
            StringBuilder q = new StringBuilder("date_from=2026-01-01&date_to=2026-06-30&importance=high&lang=en");
            if (cursor != null) {
                q.append("&cursor=").append(URLEncoder.encode(cursor, StandardCharsets.UTF_8));
            }
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/economic-events/filter?" + q))
                .timeout(Duration.ofSeconds(60))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", "pro")
                .header("Accept", "application/json")
                .GET()
                .build();
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() >= 400) {
                System.err.println(response.body());
                System.exit(1);
            }
            pages++;
            Matcher m = Pattern.compile("\"next_cursor\"\\s*:\\s*\"([^\"]+)\"").matcher(response.body());
            if (m.find()) cursor = m.group(1); else break;
        }
        System.out.println("pages: " + pages);
    }
}

/**
 * Build an actual-vs-forecast chart series from event history.
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "basic",
  Accept: "application/json",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/1057/history`);
  url.searchParams.set("released_only", "true");
  url.searchParams.set("limit", "24");
  url.searchParams.set("lang", "en");

  const response = await fetch(url, { headers: HEADERS });
  const hist = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(hist));

  const series = [...(hist.data || [])].reverse().map((row) => ({
    date: row.date,
    actual: row.actual,
    forecast: row.forecast,
    previous: row.previous,
  }));

  console.log(JSON.stringify(series, null, 2));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Build an actual-vs-forecast chart series from event history. */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: basic',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/economic-events/1057/history?' . http_build_query([
    'released_only' => 'true',
    'limit' => 24,
    'lang' => 'en',
]));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$hist = json_decode((string) $raw, true);
if ($status >= 400 || !is_array($hist)) {
    throw new RuntimeException("HTTP {$status}: {$raw}");
}

$series = [];
foreach (array_reverse($hist['data'] ?? []) as $row) {
    $series[] = [
        'date' => $row['date'] ?? null,
        'actual' => $row['actual'] ?? null,
        'forecast' => $row['forecast'] ?? null,
        'previous' => $row['previous'] ?? null,
    ];
}

echo json_encode($series, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Build an actual-vs-forecast chart series from event history.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    req, _ := http.NewRequest(
        http.MethodGet,
        "https://api.example.com/economic-events/1057/history?released_only=true&limit=24&lang=en",
        nil,
    )
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload map[string]any
    _ = json.Unmarshal(body, &payload)
    data, _ := payload["data"].([]any)
    // reverse for chronological chart order
    for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 {
        data[i], data[j] = data[j], data[i]
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(data)
}

#!/usr/bin/env bash
# Chart series: reverse history rows for chronological plotting
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"

curl -sS "${BASE_URL}/economic-events/1057/history?released_only=true&limit=24&lang=en" \
  -H "X-Api-Key: ${API_KEY}" \
  -H "X-Subscription: basic" \
  -H "Accept: application/json" \
  | jq '[.data | reverse[] | {date, actual, forecast, previous}]'

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

/** Build an actual-vs-forecast chart series from event history. */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(
                "https://api.example.com/economic-events/1057/history"
                    + "?released_only=true&limit=24&lang=en"))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println(response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

/**
 * Compare effective history limits across subscription plans.
 */
const BASE_URL = "https://api.example.com";

async function checkPlan(plan, want) {
  const url = new URL(`${BASE_URL}/economic-events/1057/history`);
  url.searchParams.set("limit", String(want));
  url.searchParams.set("lang", "en");
  url.searchParams.set("released_only", "true");

  const response = await fetch(url, {
    headers: {
      "X-Api-Key": "YOUR_API_KEY",
      "X-Subscription": plan,
      Accept: "application/json",
    },
  });
  const body = await response.json();
  console.log(
    plan,
    "requested",
    want,
    "effective_limit",
    body.meta?.limit,
    "returned",
    body.meta?.returned
  );
}

async function main() {
  for (const [plan, want] of [
    ["free", 100],
    ["basic", 100],
    ["pro", 100],
  ]) {
    await checkPlan(plan, want);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Compare effective history limits across subscription plans. */

$baseUrl = 'https://api.example.com';

foreach (['free' => 100, 'basic' => 100, 'pro' => 100] as $plan => $want) {
    $headers = [
        'X-Api-Key: YOUR_API_KEY',
        'X-Subscription: ' . $plan,
        'Accept: application/json',
    ];
    $ch = curl_init($baseUrl . '/economic-events/1057/history?' . http_build_query([
        'limit' => $want,
        'lang' => 'en',
        'released_only' => 'true',
    ]));
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
    ]);
    $raw = curl_exec($ch);
    curl_close($ch);
    $body = json_decode((string) $raw, true);
    $meta = $body['meta'] ?? [];
    echo $plan
        . ' requested ' . $want
        . ' effective_limit ' . ($meta['limit'] ?? '?')
        . ' returned ' . ($meta['returned'] ?? '?')
        . PHP_EOL;
}

package main

// Compare effective history limits across subscription plans.

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    plans := []string{"free", "basic", "pro"}
    client := &http.Client{Timeout: 30 * time.Second}

    for _, plan := range plans {
        req, _ := http.NewRequest(
            http.MethodGet,
            "https://api.example.com/economic-events/1057/history?limit=100&lang=en&released_only=true",
            nil,
        )
        req.Header.Set("X-Api-Key", "YOUR_API_KEY")
        req.Header.Set("X-Subscription", plan)
        req.Header.Set("Accept", "application/json")

        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()

        var payload map[string]any
        _ = json.Unmarshal(body, &payload)
        meta, _ := payload["meta"].(map[string]any)
        fmt.Println(plan, "effective_limit", meta["limit"], "returned", meta["returned"])
    }
}

#!/usr/bin/env bash
# Compare history caps for free / basic / pro
set -euo pipefail

BASE_URL="https://api.example.com"
API_KEY="YOUR_API_KEY"

for PLAN in free basic pro; do
  echo "=== ${PLAN} ==="
  curl -sS "${BASE_URL}/economic-events/1057/history?limit=100&lang=en&released_only=true" \
    -H "X-Api-Key: ${API_KEY}" \
    -H "X-Subscription: ${PLAN}" \
    -H "Accept: application/json" \
    | jq '{plan: .meta.plan, limit: .meta.limit, returned: .meta.returned}'
done

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

/** Compare effective history limits across subscription plans. */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        String[] plans = {"free", "basic", "pro"};
        for (String plan : plans) {
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                    "https://api.example.com/economic-events/1057/history"
                        + "?limit=100&lang=en&released_only=true"))
                .timeout(Duration.ofSeconds(30))
                .header("X-Api-Key", "YOUR_API_KEY")
                .header("X-Subscription", plan)
                .header("Accept", "application/json")
                .GET()
                .build();
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println(plan + " => " + response.body());
        }
    }
}

#!/usr/bin/env python3
"""Start Ultra export job"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "ultra",
    "Accept": "application/json",
}

response = requests.post(f"{BASE_URL}/economic-events/export", headers=HEADERS, timeout=30)
print("status:", response.status_code)
print(json.dumps(response.json(), indent=2, ensure_ascii=False))

/**
 * Start Ultra export job
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "ultra",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/economic-events/export`, {
    method: "POST",
    headers: HEADERS,
  });
  const payload = await response.json();
  console.log("status:", response.status);
  console.log(payload);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** Start Ultra export job */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: ultra',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/economic-events/export');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode((string) $raw, true);
echo "status: {$status}" . PHP_EOL;
echo json_encode($payload, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . PHP_EOL;

package main

// Start Ultra export job

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

func main() {
    req, err := http.NewRequest(http.MethodPost, "https://api.example.com/economic-events/export", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "ultra")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

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

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

/** Start Ultra export job */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/export"))
            .timeout(Duration.ofSeconds(30))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "ultra")
            .header("Accept", "application/json")
            .POST(HttpRequest.BodyPublishers.noBody())
            .build();

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

#!/usr/bin/env python3
"""NDJSON stream for a date range"""

import json
import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "X-Subscription": "ultra",
    "Accept": "application/x-ndjson",
}

params = {
    "date_from": "2026-08-01",
    "date_to": "2026-08-07",
}

with requests.get(
    f"{BASE_URL}/economic-events/stream",
    headers=HEADERS,
    params=params,
    stream=True,
    timeout=120,
) as response:
    response.raise_for_status()
    for line in response.iter_lines(decode_unicode=True):
        if not line:
            continue
        event = json.loads(line)
        print(json.dumps(event, ensure_ascii=False))

/**
 * NDJSON stream for a date range
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  "X-Subscription": "ultra",
  Accept: "application/x-ndjson",
};

async function main() {
  const url = new URL(`${BASE_URL}/economic-events/stream`);
  url.searchParams.set("date_from", "2026-08-01");
  url.searchParams.set("date_to", "2026-08-07");

  const response = await fetch(url, { headers: HEADERS });
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  const text = await response.text();
  for (const line of text.split("\n").filter(Boolean)) {
    console.log(JSON.parse(line));
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** NDJSON stream for a date range */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'X-Subscription: ultra',
    'Accept: application/x-ndjson',
];

$query = http_build_query([
    'date_from' => '2026-08-01',
    'date_to' => '2026-08-07',
]);
$ch = curl_init($baseUrl . '/economic-events/stream?' . $query);
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 120,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status >= 400) {
    throw new RuntimeException("HTTP {$status}: {$raw}");
}

foreach (preg_split('/\r?\n/', (string) $raw) as $line) {
    $line = trim($line);
    if ($line === '') {
        continue;
    }
    $event = json_decode($line, true);
    echo json_encode($event, JSON_UNESCAPED_UNICODE) . PHP_EOL;
}

package main

// NDJSON stream for a date range

import (
    "bufio"
    "fmt"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}
    q.Set("date_from", "2026-08-01")
    q.Set("date_to", "2026-08-07")

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/economic-events/stream?"+q.Encode(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "ultra")
    req.Header.Set("Accept", "application/x-ndjson")

    client := &http.Client{Timeout: 120 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d\n", resp.StatusCode)
        os.Exit(1)
    }

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if line != "" {
            fmt.Println(line)
        }
    }
}

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

/** NDJSON stream for a date range */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/economic-events/stream?date_from=2026-08-01&date_to=2026-08-07"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "ultra")
            .header("Accept", "application/x-ndjson")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

#!/usr/bin/env python3
"""HTML calendar redirect"""

import requests

BASE_URL = "https://api.example.com"
HEADERS = {
    "X-Api-Key": "YOUR_API_KEY",
    "Accept": "application/json",
}

response = requests.get(
    f"{BASE_URL}/calendar",
    headers=HEADERS,
    allow_redirects=False,
    timeout=30,
)
print("status:", response.status_code)
print("location:", response.headers.get("Location"))

/**
 * HTML calendar redirect
 */
const BASE_URL = "https://api.example.com";
const HEADERS = {
  "X-Api-Key": "YOUR_API_KEY",
  Accept: "application/json",
};

async function main() {
  const response = await fetch(`${BASE_URL}/calendar`, {
    headers: HEADERS,
    redirect: "manual",
  });
  console.log("status:", response.status);
  console.log("location:", response.headers.get("Location"));
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

<?php
declare(strict_types=1);
/** HTML calendar redirect */

$baseUrl = 'https://api.example.com';
$headers = [
    'X-Api-Key: YOUR_API_KEY',
    'Accept: application/json',
];

$ch = curl_init($baseUrl . '/calendar');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADER => true,
    CURLOPT_NOBODY => true,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_TIMEOUT => 30,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "status: {$status}" . PHP_EOL;
if (preg_match('/^Location:\s*(.+)$/mi', (string) $raw, $m)) {
    echo "location: " . trim($m[1]) . PHP_EOL;
}

package main

// HTML calendar redirect

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    q := url.Values{}

    req, err := http.NewRequest(http.MethodGet, "https://api.example.com/calendar", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("X-Api-Key", "YOUR_API_KEY")
    req.Header.Set("X-Subscription", "basic")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode >= 400 {
        fmt.Fprintf(os.Stderr, "HTTP %d: %s\n", resp.StatusCode, body)
        os.Exit(1)
    }

    var payload any
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "  ")
    _ = enc.Encode(payload)
}

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

/** HTML calendar redirect */
public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/calendar"))
            .timeout(Duration.ofSeconds(120))
            .header("X-Api-Key", "YOUR_API_KEY")
            .header("X-Subscription", "basic")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            System.err.println("HTTP " + response.statusCode() + ": " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}