API Documentation

import React, { useState, useEffect, useRef } from 'react';

const DATASET_ID = 'YOUR_DATASET_ID';
const PUBLIC_KEY = 'ac_pub_YOUR_KEY'; // Safe for browsers: read-only scope
const API_BASE = 'https://typosuggest.pial.digital';

export default function SearchAutocomplete() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);
  const [error, setError] = useState(null);
  const requestSeq = useRef(0);

  useEffect(() => {
    const trimmed = query.trim();
    if (!trimmed) {
      setResults([]);
      setError(null);
      return;
    }

    const seq = ++requestSeq.current;
    const controller = new AbortController();

    const timer = setTimeout(async () => {
      try {
        // Passing ?key= in URL avoids browser CORS OPTIONS preflight
        const url = `${API_BASE}/v1/suggest?dataset_id=${encodeURIComponent(DATASET_ID)}&q=${encodeURIComponent(trimmed)}&limit=6&key=${encodeURIComponent(PUBLIC_KEY)}`;
        const res = await fetch(url, { signal: controller.signal });
        if (!res.ok) {
          const errBody = await res.json().catch(() => ({}));
          throw new Error(errBody.error || `HTTP ${res.status}`);
        }
        const data = await res.json();
        if (seq === requestSeq.current) {
          setResults(Array.isArray(data.suggestions) ? data.suggestions : []);
          setError(null);
        }
      } catch (err) {
        if (err.name === 'AbortError') return;
        if (seq === requestSeq.current) {
          console.error('Suggest error:', err);
          setError(err.message);
        }
      }
    }, 120);

    return () => {
      clearTimeout(timer);
      controller.abort();
    };
  }, [query]);

  return (
    <div style={{ position: 'relative', width: '360px' }}>
      <input
        type="text"
        value={query}
        onChange={(e) => setQuery(e.target.value)}
        placeholder="Search products, services, news..."
        style={{ width: '100%', padding: '10px 14px', border: '1px solid #E5E2DC', borderRadius: '8px', outline: 'none' }}
      />
      {error && <div style={{ color: '#b91c1c', fontSize: '12px', marginTop: '4px' }}>{error}</div>}
      {results.length > 0 && (
        <ul style={{ position: 'absolute', top: '100%', left: 0, right: 0, background: '#fff', border: '1px solid #E5E2DC', borderRadius: '8px', listStyle: 'none', margin: '4px 0 0 0', padding: '4px 0', boxShadow: '0 4px 12px rgba(0,0,0,0.05)', zIndex: 50 }}>
          {results.map((item) => (
            <li key={item.text} style={{ padding: '8px 14px', cursor: 'pointer', borderBottom: '1px solid #F4F3EE', fontSize: '13px' }}>
              {item.text}
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}

const API_BASE = 'https://typosuggest.pial.digital';
const DATASET_ID = 'YOUR_DATASET_ID';
const PUBLIC_KEY = 'ac_pub_YOUR_KEY';

let activeController = null;

async function queryAutocomplete(keyword) {
  const trimmed = keyword.trim();
  if (!trimmed) return [];

  if (activeController) activeController.abort();
  activeController = new AbortController();

  const url = `${API_BASE}/v1/suggest?dataset_id=${encodeURIComponent(DATASET_ID)}&q=${encodeURIComponent(trimmed)}&limit=5&key=${encodeURIComponent(PUBLIC_KEY)}`;
  const res = await fetch(url, { signal: activeController.signal });
  if (!res.ok) {
    const errBody = await res.json().catch(() => ({}));
    throw new Error(errBody.error || `HTTP ${res.status}`);
  }
  const data = await res.json();
  return Array.isArray(data.suggestions) ? data.suggestions : [];
}

// Server-side only: keep your ac_sec_... key in environment variables
async function indexProduct(product) {
  const API_BASE = 'https://typosuggest.pial.digital';
  const datasetId = process.env.TYPOSUGGEST_DATASET_ID;
  const secretKey = process.env.TYPOSUGGEST_SECRET_KEY; // ac_sec_...

  const res = await fetch(`${API_BASE}/v1/datasets/${encodeURIComponent(datasetId)}/items:add`, {
    method: 'POST',
    headers: {
      'X-API-Key': secretKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      items: [
        { id: String(product.id), text: product.title, group: product.category || 'product', count: 1 }
      ]
    }),
    signal: AbortSignal.timeout(10000)
  });

  const payload = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(`TypoSuggest ingest failed (${res.status}): ${payload.error || res.statusText}`);
  }
  return payload; // { added, skipped_duplicates, active_phrases, took_ms }
}

import os
import requests

API_BASE = "https://typosuggest.pial.digital"
DATASET_ID = "YOUR_DATASET_ID"
SECRET_KEY = os.environ.get("TYPOSUGGEST_SECRET_KEY", "ac_sec_YOUR_KEY")

res = requests.post(
    f"{API_BASE}/v1/datasets/{DATASET_ID}/items:add",
    headers={"X-API-Key": SECRET_KEY, "Content-Type": "application/json"},
    json={
        "items": [
            {"id": "sku-1", "text": "Apple MacBook Pro 16 inch M3 Max", "group": "product", "count": 25},
            {"id": "sku-2", "text": "Modern WordPress Website Development", "group": "gig", "count": 10},
        ]
    },
    timeout=5.0,
)
if not res.ok:
    raise RuntimeError(f"Ingest failed ({res.status_code}): {res.text}")

payload = res.json()
print(f"Added {payload.get('added', 0)} items ({payload.get('active_phrases', 0)} active phrases)")

package main

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

type Suggestion struct {
	Text      string  `json:"text"`
	Group     string  `json:"group"`
	Score     float64 `json:"score"`
	Frequency uint32  `json:"frequency"`
}

type SuggestResponse struct {
	Query       string       `json:"query"`
	TookMs      float64      `json:"took_ms"`
	Suggestions []Suggestion `json:"suggestions"`
}

func Suggest(ctx context.Context, query string) (*SuggestResponse, error) {
	client := &http.Client{Timeout: 5 * time.Second}
	u, _ := url.Parse("https://typosuggest.pial.digital/v1/suggest")
	q := u.Query()
	q.Set("dataset_id", "YOUR_DATASET_ID")
	q.Set("q", query)
	q.Set("limit", "8")
	u.RawQuery = q.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-API-Key", "ac_pub_YOUR_KEY")

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

	if resp.StatusCode != http.StatusOK {
		var apiErr struct {
			Error string `json:"error"`
		}
		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
		return nil, fmt.Errorf("typosuggest HTTP %d: %s", resp.StatusCode, apiErr.Error)
	}

	var out SuggestResponse
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return nil, err
	}
	return &out, nil
}

curl "https://typosuggest.pial.digital/v1/suggest?dataset_id=YOUR_DATASET_ID&q=macbook&limit=5" \
  -H "X-API-Key: ac_pub_YOUR_KEY"