Perkusai API for AI assistants

curl -s --get https://perkusai.lt/api/ai/search \
  --data-urlencode "q=vaikiškas dviratis" \
  --data-urlencode "k=3"

import requests

r = requests.get(
    "https://perkusai.lt/api/ai/search",
    params={"q": "vaikiškas dviratis", "k": 3},
    timeout=30,
)
r.raise_for_status()

for p in r.json()["results"]:
    print(f"{p['title']} — {p['price']} {p['currency']} — {p['buy_url']}")

const url = new URL("https://perkusai.lt/api/ai/search");
url.searchParams.set("q", "vaikiškas dviratis");
url.searchParams.set("k", "3");

const res = await fetch(url, { signal: AbortSignal.timeout(30_000) });
if (!res.ok) throw new Error(`Perkusai: HTTP ${res.status}`);
const data = await res.json();

for (const p of data.results) {
  console.log(`${p.title} — ${p.price} ${p.currency} — ${p.buy_url}`);
}

<?php
$url = 'https://perkusai.lt/api/ai/search?' . http_build_query([
    'q' => 'vaikiškas dviratis',
    'k' => 3,
]);
$ctx = stream_context_create(['http' => ['timeout' => 30]]);

$data = json_decode(file_get_contents($url, false, $ctx), true);

foreach ($data['results'] as $p) {
    printf("%s — %.2f %s — %s\n", $p['title'], $p['price'], $p['currency'], $p['buy_url']);
}

require "json"
require "net/http"

uri = URI("https://perkusai.lt/api/ai/search")
uri.query = URI.encode_www_form(q: "vaikiškas dviratis", k: 3)

data = JSON.parse(Net::HTTP.get(uri))

data["results"].each do |p|
  puts "#{p['title']} — #{p['price']} #{p['currency']} — #{p['buy_url']}"
end

package main

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

type response struct {
	Results []struct {
		Title    string  `json:"title"`
		Price    float64 `json:"price"`
		Currency string  `json:"currency"`
		BuyURL   string  `json:"buy_url"`
	} `json:"results"`
}

func main() {
	q := url.Values{"q": {"vaikiškas dviratis"}, "k": {"3"}}
	client := &http.Client{Timeout: 30 * time.Second}

	res, err := client.Get("https://perkusai.lt/api/ai/search?" + q.Encode())
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var data response
	if err := json.NewDecoder(res.Body).Decode(&data); err != nil {
		panic(err)
	}
	for _, p := range data.Results {
		fmt.Printf("%s — %.2f %s — %s\n", p.Title, p.Price, p.Currency, p.BuyURL)
	}
}

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }
//             serde_json = "1"
//             tokio = { version = "1", features = ["full"] }
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let data: serde_json::Value = client
        .get("https://perkusai.lt/api/ai/search")
        .query(&[("q", "vaikiškas dviratis"), ("k", "3")])
        .send()
        .await?
        .json()
        .await?;

    if let Some(items) = data["results"].as_array() {
        for p in items {
            println!("{} — {} {} — {}", p["title"], p["price"], p["currency"], p["buy_url"]);
        }
    }
    Ok(())
}

using System.Text.Json;

var q = Uri.EscapeDataString("vaikiškas dviratis");
var url = $"https://perkusai.lt/api/ai/search?q={q}&k=3";

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
using var doc = JsonDocument.Parse(await http.GetStringAsync(url));

foreach (var p in doc.RootElement.GetProperty("results").EnumerateArray())
{
    Console.WriteLine($"{p.GetProperty("title")} — {p.GetProperty("price")} " +
                      $"{p.GetProperty("currency")} — {p.GetProperty("buy_url")}");
}

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;

var q = URLEncoder.encode("vaikiškas dviratis", StandardCharsets.UTF_8);
var request = HttpRequest.newBuilder()
        .uri(URI.create("https://perkusai.lt/api/ai/search?q=" + q + "&k=3"))
        .timeout(Duration.ofSeconds(30))
        .build();

var response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString());

System.out.println(response.body());   // JSON — parse with Jackson or Gson