Forem: mv7

I gave the OpenAI SDK live web search by changing one line

mv7 — Fri, 15 May 2026 11:12:33 +0000

Last week I was stitching together Serper for web + Tavily for synthesis + a YouTube transcript API just to answer one chat question. Every category was a new API contract, a new auth flow, a new JSON shape my agent had to know about.

I almost wrote a wrapper SDK. Then I realized I didn't need to — the openai SDK can already do all of this. You just point it at a different base_url.

Here's the trick

from openai import OpenAI

client = OpenAI(
    api_key="pxs_...",                        # pixserp key, not OpenAI
    base_url="https://pixserp.com/api/v1",    # one URL change
)

r = client.chat.completions.create(
    model="pixserp-standard",
    messages=[{"role": "user", "content": "EU AI Act enforcement timeline 2026"}],
)
print(r.choices[0].message.content)
print(r.choices[0].message.citations)

That's it. The openai SDK doesn't know it's talking to a search backend. It thinks it's calling chat.completions.create. The server does the routing — runs the searches, fetches pages, synthesizes a cited answer — and returns a standard OpenAI assistant message.

Inline [1], [2] markers in content. Structured message.citations array with one entry per source. Drop into your existing typed code, render in your existing UI.

Why this works at all

The openai SDK doesn't validate response shape strictly — it expects the OpenAI wire format and serializes whatever comes back into a ChatCompletion object. As long as the server returns:

choices[*].message.role = "assistant"
choices[*].message.content (the cited text)
Standard usage block
Optional extra fields (citations, cost) accessible via model_extra

…it just works. Same SSE streaming for stream=True. Same response_format: { type: "json_schema" } for structured output. Same tool_calls shape on the response if the backend wants to surface internal steps.

A search backend that speaks chat-completions is a drop-in for any code that already speaks OpenAI. No wrapper, no new SDK, no second auth flow.

More than just "web"

The thing that pushed me over the edge to drop the wrapper plan: pixserp routes to ten different answer shapes through the same endpoint.

def ask(q, model="pixserp-standard"):
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": q}],
    )
    return r.choices[0].message.content, r.choices[0].message.citations

ask("Cheapest direct MXP→JFK on July 18 in economy")
ask("Hotels in Barcelona Jul 15–20, 4 stars or more")
ask("Summarize https://www.youtube.com/watch?v=jNQXAC9IVRw in 5 bullets")
ask("iPhone 15 Pro under $900 with free shipping")
ask("Best ramen near Porta Garibaldi")

Flights, hotels, places, shopping, transcripts, news, images — all the same call. The citations array carries per-shape structured fields: rating, price, gps, hours, airline, check_in. Your renderer can show real cards instead of bare links.

I'm not using all ten verticals in my app yet. But I'm not paying a "stitching tax" anymore either.

Streaming works the way you expect

The bit that mattered most for the chat UI:

stream = client.chat.completions.create(
    model="pixserp-fast",
    messages=[{"role": "user", "content": "What did the Fed announce today?"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Standard OpenAI SSE. The delta shape is the one your code already handles. Citations land on the final chunk in delta.citations (or via model_extra depending on your SDK version) so the references panel can render once the answer settles.

I dropped a custom EventSource handler I'd written for a different vendor — back to the stock openai stream parser.

Per-call cost on a header

The bit dev.to readers ask about most after "does it work": cost visibility. Pixserp puts the per-call cost on the response header:

x-cost-usd: <decimal value per request>

Stick that into your structured logs and you've got per-call cost-per-customer, per-feature, per-route — without paying for a third-party billing analytics tool.

Gotchas (the honest part)

Five things I tripped over while migrating:

Don't bring your own retries. The server handles upstream-vendor retries (Google Flights timing out, etc.) and surfaces a definitive answer or a definitive error. Wrapping a retry loop around chat.completions.create in your app double-counts and burns credit. Trust the server, fail fast on 4xx.
tool_calls are not OpenAI function calls. If the response includes a tool_calls array, those are the internal retrieval steps surfaced for transparency (which page fetches, which searches). They are NOT a request for you to execute a function — there's no tool-loop to close. Don't submit_tool_outputs. Render them or ignore them.
Context windows are smaller than chat models. Search synthesis is fast and short by design; if you throw a 30k-token system prompt at it, you're paying for tokens you won't use. Keep the user message focused on the question.
response_format: json_schema is web-grounded, not free-form. If you ask for {"answer": str, "year": int} and the live web doesn't know the year, the field will be null — not hallucinated. That's the feature, but worth knowing if your downstream code expects a non-null value.
Streaming delta.citations shape depends on SDK version. pip show openai ≥ 1.55 exposes them in the typed delta. Older versions: read citations from r.choices[0].message.model_extra after the stream completes.

Wrapping up

If you're already calling openai.chat.completions.create, adding live web search to your agent is a base_url swap and a model-name change. No new SDK. No new auth pattern. No "we'll do it next sprint" because the integration shape changed.

For the full reference see pixserp's docs. Free credit on signup if you want to throw a real workload at it — no card.

I'm shipping the rest of my agent's verticals on top of this now. If you've been stitching three or four search APIs together for one chat reply, take fifteen minutes and try the swap. It's the smallest amount of code I've ever deleted to add a feature.

pixserp is an OpenAI-compatible AI search API — docs · pricing. Built at Teti AI.

Meet pixserp — One Drop-in API for Web, News, Places, Flights, Hotels, YouTube and Anything Else on the Live Web

mv7 — Wed, 13 May 2026 14:48:26 +0000

If you've built an AI agent in 2026, you've probably integrated more "search" APIs than you'd like to admit. One for web pages. One for news. One for product prices because the SERP one doesn't return shopping cards. One for flights, because of course none of the above know about flights. One for YouTube transcripts. Each with its own SDK, its own JSON shape, its own pricing model, its own bill at month-end.

We were there too. We built Teti AI — an AI assistant used daily by hundreds of thousands of people — and behind every conversation there's a live web lookup. Millions a day. Sometimes it's a news headline. Sometimes a flight, a hotel, a product, a YouTube summary. All of those are "search" from the user's point of view, even if no single search API covers them. That's where pixserp was born.

This post is the short version of what pixserp is and why we think you should care if you're shipping anything LLM-shaped.

The setup: one endpoint, ten shapes

pixserp is an AI search API with a single twist: one endpoint covers ten different shapes of answer. You write a natural-language question; the agent figures out which vertical the answer lives in.

from openai import OpenAI

client = OpenAI(api_key="pxs_…", base_url="https://pixserp.com/api/v1")

def ask(q):
    r = client.chat.completions.create(
        model="pixserp-fast",
        messages=[{"role": "user", "content": q}],
    )
    return r.choices[0].message

# Same call. Different shapes of answer. One bill.
ask("Best practices for Postgres index maintenance in 2026")      # web
ask("latest news on AI startup funding this week")                # news
ask("top-rated ramen near Porta Garibaldi, Milan")                # places
ask("iPhone 15 Pro under $900 with free shipping")                # shopping
ask("cheapest direct MXP→JFK on July 18, economy")                # flights
ask("hotels in Barcelona Jul 15-20, 4★+, under $250/night")       # hotels
ask("summarize https://youtu.be/dQw4w9WgXcQ in 5 bullets")        # YouTube + transcript
ask("extract the key claims from https://example.com/article")    # any URL

You don't pick the vertical. You don't switch endpoints. You just ask, and you get back a cited answer with structured per-shape fields — rating and address for places, price and store for shopping, flight numbers and segments for flights, etc.

Why "OpenAI-compatible" matters

The wire format is the standard chat.completions shape, which means anything that speaks OpenAI's API speaks pixserp. Swap base_url and you're done:

The official openai Python / JS / Go SDKs work
LangChain works (use ChatOpenAI with api_base)
LlamaIndex works (OpenAILike)
Vercel AI SDK works (createOpenAI with baseURL)
Cursor, Continue, any tool that lets you set a base URL works
curl works (it's just HTTP)

No bespoke client to install. No per-framework adapter to maintain. The same code that talks to GPT-4 talks to pixserp, just pointed at a different host.

import OpenAI from "openai";

const pixserp = new OpenAI({
  apiKey:  "pxs_…",
  baseURL: "https://pixserp.com/api/v1",
});

const r = await pixserp.chat.completions.create({
  model:    "pixserp-fast",
  messages: [{ role: "user", content: "Latest CRISPR developments in 2026" }],
});

console.log(r.choices[0].message.content);       // cited answer prose
console.log(r.choices[0].message.citations);     // structured sources

Citations are first-class

Every fact in the answer comes back with both an inline [1] marker and a structured entry in message.citations. Each entry has a kind (web, news, place, shopping, flight, hotel, video, transcript, image, webpage) plus per-kind structured fields. UI rendering becomes "render the cards", not "parse free-form prose":

{
  "id":     "1",
  "kind":   "place",
  "title":  "Ippudo NY",
  "rating": 4.5,
  "address": "65 4th Ave, New York, NY 10003",
  "url":    "https://www.google.com/maps/place/…",
  "markdown": "**Ippudo NY** — 4.5★ · 65 4th Ave · New York"
}

Drop into a card component, you have a working place card without writing a single regex over markdown.

Pricing — flat per request

This is where we differ most from the rest of the category.

Model	Use for	Price
`pixserp-fast`	Quick lookups, chat-style	$1.50 / 1k
`pixserp-standard`	Balanced research	$2.50 / 1k
`pixserp-deep`	Multi-angle thorough	$3.50 / 1k
`pixserp-agent`	Multi-step research loop (up to 100 steps)	$0.0035 / step

For comparison, May 2026 list prices on the rest of the category:

Exa: $7–$15 / 1k + extra $1 / 1k per content-type fetch
Tavily: $8–$16 / 1k pay-as-you-go
Perplexity Sonar: $1–$15 per 1M tokens + an extra $14–$22 / 1k on Pro Search
Brave Summarizer: async polling, multi-second floor

We're cheaper than Exa by ~4×, cheaper than Tavily by ~5×, and predictable in a way per-token APIs aren't. No per-token roulette, no metered sub-calls to count, no end-of-month surprises. You know the cost before you call.

How? Because we have one variable (request count) instead of N (tokens × pages × searches × verticals). The variance averages out at scale; we price the average plus a margin and offer it back as a fixed unit. The teams we talked to before launching this pricing all had the same story: "month one was fine, month three the bill was 4× projected because traffic shifted toward harder questions." Flat pricing ends that.

Streaming, JSON schema, MCP

A few other things that ship by default:

SSE streaming — same OpenAI wire format. stream: true and you get token-by-token chunks. Time-to-first-token on pixserp-fast is ~1 second.

JSON schema outputs — pass response_format with a schema, get JSON back with web-grounded values. No parsing, no validation gymnastics:

r = client.chat.completions.create(
    model="pixserp-fast",
    messages=[{"role": "user", "content": "Top 3 aerospace companies, CEO, founded year"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "companies",
            "schema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name":         {"type": "string"},
                                "ceo":          {"type": "string"},
                                "founded_year": {"type": "integer"},
                            },
                            "required": ["name", "ceo", "founded_year"],
                        },
                    },
                },
            },
        },
    },
)

import json
for c in json.loads(r.choices[0].message.content)["companies"]:
    print(c["name"], "—", c["ceo"], "—", c["founded_year"])

MCP server — we also ship a dedicated Model Context Protocol server so any MCP-compatible client (Claude Desktop, Cursor, Zed, Claude Code, Cline, Continue) can pick up pixserp as a search tool with one config block. Full install configs are at pixserp.com/mcp.

What it deletes from your codebase

If you're coming from a stitched-together setup (SerpAPI + scraper + your own LLM synthesis), what you can delete:

Result-picking logic — pixserp picks which URLs to fetch.
Page scraper (Playwright / BeautifulSoup / trafilatura) — content extraction is server-side.
HTML cleaner / boilerplate stripper — same.
Token-budget truncator — pixserp returns a final answer, not raw context.
Citation-marker injector — built into the response.
The second LLM call for synthesis — pixserp is the synthesis. You delete the OpenAI bill underneath.
Per-vertical clients (flight API, hotels API, shopping API, YouTube transcript service) — all behind the same endpoint now.

If that stack is ~300 lines and three separate vendor accounts, you delete ~300 lines and consolidate three accounts.

Honest comparison with the rest of the category

We're hardly the only AI search API. If you're evaluating:

Exa is the right pick if you specifically want embedding-similarity over papers/blogs and synthesis isn't part of the job. Their /contents endpoint is solid for "find me posts similar to X".
Tavily is the most pragmatic for plain web/news Q&A if you don't need streaming, structured outputs, or any verticals beyond web/news.
Perplexity Sonar is the right pick if you want their consumer-product research engine specifically, and you're OK with per-token pricing.
Brave Search is great if you only need raw SERP results and want a simple per-1k web/news/images call. No native synthesis, no agent.

pixserp is the pick if:

You want one endpoint that handles web + news + places + shopping + flights + hotels + YouTube + transcripts + any URL — without integrating four separate APIs.
You want flat per-request pricing so finance can model your bill.
You want a drop-in OpenAI-compatible wire format so existing code works.
You want structured citations with per-shape fields, not just URL lists.

Where to go next

If you want to try it:

Get an API key — $2.50 free credit on signup, no card.
Point your base_url at https://pixserp.com/api/v1.
Pick a model — start with pixserp-fast for chat, pixserp-standard for research.
Ship. Your existing chat.completions.create() code keeps working.

Docs and per-language quickstarts: pixserp.com/docs. MCP install: pixserp.com/mcp. Playground (in-browser, no setup): pixserp.com/playground.

We run Teti AI on this exact stack. If pixserp goes down, Teti goes down too — so the uptime expectations are the same as our own product. Drop it in and tell us what you build.

— The Teti AI team