Octen AI Search API: Search, Extract and Embed on One Key

Give your agent live web search, page extraction and embeddings in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to run an Octen web search for "reddit api pricing changes 2025", take the top three URLs, extract each page to markdown, and give me a table with the title, the URL, the date it was last crawled and a one-line summary.

One prompt searches, reads and summarises. 1 min setup · 9-18 hrs saved.

You want your agent to look something up on the live web, read the pages it finds, and maybe index them for later. Octen does all three: a search engine, a page extractor and an embedding model. This guide shows how to call each one without opening a provider account, what comes back (we ran every endpoint on 2026-10-16), and five traps in the output, from a result last crawled more than a year ago to a full-content body cut mid-word. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to use the Octen AI search API?

Monid. Install it once, add a key, and your agent calls Octen search, extract, broad search and embeddings with no provider signup, no plan and no second invoice.

• Pay per call. A search is billed on its own, at $0.001 per call (Verified 2026-10-16 on the web search tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every API. The same key and the same balance call Octen and every other tool on Monid. When your agent needs a second search source or a scraper next, it is another call on the same balance, not another vendor.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs them, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At that price, 100 searches cost about $0.10 (Verified 2026-10-16). If Bing was your search source, the retired Bing Search API alternatives lists what to switch to.

How do you call Octen search, extract and embeddings?

Run one call per job: /search to find pages, /extract to read them, /embedding to index them. The provider key is octen and every endpoint takes a JSON body. Monid lists four of them, and the table shows where each route stands.

Monid fits an agent because every step is a small call you pay for when it runs, and nothing sits idle between runs.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Search

monid run -p octen -e /search -i '{"query": "reddit api pricing changes 2025", "count": 10}'

The call returns ranked results, each with a highlight of passages picked for the query. The price is per call, whatever count is.

Search with the full page text

monid run -p octen -e /search \
  -i '{"query": "reddit api pricing changes 2025", "count": 5, "full_content": {"enable": true}}'

Turning on full_content adds a body to each result and a second billing line per 1,000 tokens of body returned.

Search from several angles

monid run -p octen -e /broad-search \
  -i '{"query": "how do AI agents get live web data without a browser", "max_queries": 5}'

Broad search writes its own sub-queries from your question and runs them side by side. max_queries is the cap on how many.

Extract and embed

monid run -p octen -e /extract -i '{"urls": ["https://monid.ai/blog/guides/reddit-scraper"], "format": "markdown"}'
monid run -p octen -e /embedding -i '{"input": ["reddit api pricing", "how much does the reddit api cost"]}'

Extract takes up to 20 URLs per call. Embedding takes a list of strings and returns one vector per string.

Or hand the whole job to an agent

For the same search-then-read shape wired as a tool your agent calls, live web search your agent can call shows the loop end to end.

Can you build web search and page extraction yourself with Python?

Yes, for a small corpus it is a weekend. You fetch pages with requests or Playwright, convert the HTML to text, and score pages against a query. That covers pages you already know about.

What you cannot do yourself is search the open web. A search call needs an index of the web behind it, and building a crawler wide enough to answer arbitrary queries is a different project from a script. The parts around it add up: proxies and blocking, rendering for script-heavy pages, text cleanup so the model gets prose and not navigation, a date for each page, and an embedding step with a model you host or rent.

The Monid route is the choice for anything you will run more than once. Search is one call at $0.001 (Verified 2026-10-16), extraction is one call per page, the output is typed JSON with dates instead of HTML you parse, and the index behind it is not yours to run. A hand-written fetch loop is quicker for a single known page, but it is a script for that page, not a search. If you only want a search call you can keep, the free web search API options for agents compares what each route leaves you to maintain.

What does Octen search return, and what can you build with it?

Octen search returns ranked web results, each with passages picked for the query, a publish date and a crawl date. We ran /search for reddit api pricing changes 2025 on 2026-10-16 and got five rows, so the fields below are what came back.

The result row

{ "title": "Reddit API in 2026: Pricing, Rate Limits & What Works | SocialCrawl",
  "url": "https://socialcrawl.dev/blog/reddit-data-api-2026",
  "authors": "SocialCrawl",
  "time_published": "2026-06-26T00:00:00Z",
  "time_last_crawled": "2026-09-12T11:18:46Z",
  "highlight": "…passages picked for the query, joined with ' ... '…",
  "full_content": "",
  "favicon": "https://socialcrawl.dev/apple-icon.png" }

Eight fields per row. highlight is a set of passages from the page, not a one-line snippet. full_content is an empty string until you turn it on. The response also carries a meta.usage block (num_search_queries, full_content_tokens, full_content_extra_count) and a meta.latency number: 106 on our call, with the call taking about 1.2 seconds on the wall clock.

The input takes query (required, up to 500 characters), count (1 to 100), topic (general or news), include_domains and exclude_domains, include_text and exclude_text, time_range or start_time and end_time, country, highlight and full_content options, and safesearch.

What the other endpoints return

Extract returned, for a page that loaded, url, status, title, full_content, time_last_crawled, a category and a page_structure (each with a primary and secondary label) and resolved_mode. Broad search returned queries (the sub-queries it wrote) and search_results, one group per sub-query with its own results and latency. Embedding returned model and a results list with an embedding and an index per input.

What you can build with it

• A research step. Your agent searches, filters by time_range, and reads the three best pages with extract. The prompt at the top does this in one go. Turning any URL into LLM-ready markdown goes deeper on the reading half.
• A news or pricing watcher. Run the same search with topic: "news" on a schedule and compare the time_published values against the last run.
• A small retrieval index. Embed the extracted pages with /embedding and store the vectors. Two paraphrases we embedded, "reddit api pricing" and "how much does the reddit api cost", came out at a cosine of 0.781.
• A domain-scoped search. Pass include_domains to search only the sites you trust, such as documentation hosts.

What goes wrong when you put Octen in an agent loop?

Five things showed up in our runs, and each has a one-line fix in your code.

Why can a result be more than a year old?

Because time_last_crawled is per page. Our five results were last crawled between 2025-09-09 and 2026-09-12, on a query made 2026-10-16: one page had not been re-crawled for more than a year, another for about a month. time_published ran from 2023-07-11 to 2026-06-26. If recency matters, read time_last_crawled, drop rows older than your cutoff, or send the URL through /extract, which returned a crawl stamp of 2026-10-16 for a page we fetched.

Why is a date field sometimes empty?

Because the field is a string and some pages have no value for it. In the broad search run, one result had time_last_crawled: "" and another had time_published: "". A filter like row.time_published > cutoff treats an empty string as false for every comparison. Check for the empty string before you compare, and decide whether an undated page stays or goes.

Why does the full-content body stop mid-sentence?

Because full_content.max_tokens is a hard cap. We set it to 500 on a two-result run and the first body ended mid-word, at "unauthenticated a". The default cap is 2,048 tokens per result and the schema allows up to 100,000. Set the cap for the longest page you want whole, or use /extract on the URLs you care about and keep search for finding them.

Why does a full-content search cost more than a search?

Because the body is billed by the token on top of the call. Our two-result run reported full_content_tokens: 1053 and billed 2,053 micro-dollars: 1,000 for the call plus 1,053 for the tokens, one micro-dollar per token. The bill matched meta.usage to the token. Read that field to budget a loop, and leave full_content off when the highlight is enough.

Why is a broad search never one call?

Because it bills per sub-query. A broad search with max_queries: 3 wrote three sub-queries, returned three results for each (nine rows, nine different URLs on this run) and billed three units at $0.001 each (Verified 2026-10-16). The groups are not merged, so the same page can appear under two sub-queries on another question, and you de-duplicate by url yourself. The call took about 3.1 seconds, because it runs the sub-queries and then returns. Set max_queries on purpose. If you also use another search engine, Tavily API or one key compares what different engines return for the same query.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. Search for finding pages, broad search for a question with several angles, extract for reading the pages you picked, embedding for the index. The embedding endpoint defaults to octen-embedding-4b, which returned 2,560 numbers per input on our run. The 0.6b model is the low-cost one and the 8b model the highest accuracy, each priced by the million tokens.

For a second search source on the same key, the web search tools page lists the others.

When is another route a better fit?

You need a page's current state. Search returns what the index holds, with a crawl date that can be a year old. For a page whose content changes daily, extract the URL directly instead.

You need one payload per URL. Extract returns either whole-page content or query-focused highlights, depending on whether you pass query, so getting both from one call is not possible. Two payloads means two calls.

You already have a vector store. Vectors from different models do not mix, so embedding new documents with Octen into an index built on another model means re-embedding the old ones.

You want a full Google-style results page. Octen returns pages, not the ads, maps and knowledge panels of a consumer search engine. If your task is reading those, a SERP-style source is the better tool, and the SERP API guide for AI agents shows what that returns.

And the disclosure: we resell this endpoint. What we measured above is a small sample, five search results, three sub-queries, two URLs and two sentences. Use it to know which fields to expect and where the traps are, not as a benchmark.

Conclusion

The easiest way to use the Octen AI search API is through Monid: $0.001 a search (Verified 2026-10-16), one key for search, extract, broad search, embeddings and every other tool, about a minute to set up and ready inside your agent whenever you need it. Building your own search is not a weekend project, and the parts around extraction are hours of upkeep.

Two things matter more than the endpoint you pick. Read the dates: time_last_crawled told us a page was over a year old, and some date fields come back empty. And read meta.usage before you loop, because full content bills by the token and broad search bills by the sub-query.

How we estimated the time saved: wiring a search provider with its own account and billing is roughly 3 to 6 hours, building a page-to-markdown extraction step is 3 to 6 hours more, and adding embeddings with a model you host or pay for separately is another 3 to 6. That is 9 to 18 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p octen -e /search, then make one call with count set to 3 and read the two dates on each row. Start at monid.ai.

FAQ

Published September 2026.