All integrations

APIpie

AI · AI

Chat completions, embeddings, image generation, and RAG collections on their own key.

Connect APIpie with Fabriq Developer

Your user pastes their APIpie credential on a page Agentic Fabriq hosts, so it never reaches your backend and never becomes one shared key across all of your users. Same call as OAuth, one more argument.

from af_sdk import AgenticFabriq

af = AgenticFabriq()                      # reads AF_APP_ID / AF_APP_SECRET

url = await af.initiate_connection(request, provider="apipie_ai", method="api_key")
return redirect(url)                      # an AF-hosted page, not yours

async with await af.for_user(request) as session:
    tools = await session.get_tools()     # only what this user granted

Provider names are surfaces, not vendors, and the authoritative list is the capabilities endpoint rather than any page including this one — an unknown name returns 400 with the valid list. Fabriq Developer is free to start and needs no provider paperwork. Start free or read the quickstart.

Connecting APIpie in practice

APIpie is an aggregator, so the rate limit that actually applies to a call is whichever upstream provider its router picked — and its answer to that is AI Model Pooling, which groups similar models for redundancy and failover instead of publishing a per-key ceiling. A single request can also fan out to up to 5 models at once, which multiplies the cost of one logical call.

Worth knowing

  • The Chat Completions endpoint is deliberately OpenAI-compatible, so an existing client works by swapping base URL and key — which also means an agent can be pointed at APIpie without anyone noticing the provider changed.
  • Preferred Routing chooses between performance-optimised and cost-optimised handling, so two identical requests can be answered by different models; the agent has to read which model responded rather than assume it.
  • Multi-model queries accept up to 5 models in one request, so cost and latency are a function of how many were asked, not of how many requests were made.
  • APIpie publishes no numeric rate limit or quota figures in its documentation, so throughput and spend have to be bounded on the client side.

Checked against APIpie API reference (2026-09-29), APIpie features overview (2026-09-29)

Acts as the person, not as itself

Each user connects their own account. Every call carries both identities — the agent and the person it is acting for — so the agent can never reach past what that individual can already do.

Credentials never touch the agent

Tokens live in the vault and attach server-side at call time. The agent holds a session, not a secret, and revoking access does not mean rotating a key.

Every call on the record

Who asked, which agent acted, which action ran, and the verdict that let it through — one audit trail across every integration, not one per vendor.

What an agent can do

Each action is granted on its own. An agent allowed to read is not thereby allowed to write, and the scope beside each row is what the acting user must have connected for it to run at all.

apipie_ai_delete_v1_stateWRITE

DESTRUCTIVE AND IRREVERSIBLE. Delete whole state records. With `user` it deletes that one end user's record; WITHOUT `user` it deletes EVERY state record for this API key or app, which is the wider of the two operations and the default. There is no undo: the model, memory, integrity, search and system-prompt configuration is gone and every subsequent call falls back to whatever the calling application sends. To remove a few settings instead, use the `delete` array on Create or update the stored configuration state via DELETE /v1/state

api
apipie_ai_get_v1_modelsREAD

List the models APIpie can route to, filterable by `type` (llm, vision, embedding, image, voice, moderation, coding, free), `subtype`, `provider`, `combination`, `enabled`, `voices` and `restrictions`. This is a PUBLIC catalogue: measured 2026-09-27, it answers 200 with the full model list to no credential at all, so a 200 from it says nothing about whether the connection's key is valid via GET /v1/models

api
apipie_ai_get_v1_models_detailedREAD

The same catalogue with the per-model detail -- pricing, context length, capabilities and availability -- narrowed by `type`, `provider` or a single `model`. This is what to read before choosing a model for a chat completion. Also PUBLIC: measured 2026-09-27 it answers 200 to no credential at all via GET /v1/models/detailed

api
apipie_ai_get_v1_queriesREAD

Page through this account's own past API calls, newest first: per call the model, provider, route, prompt and response token counts, cost, latency and source IP. `show` buckets them (all, hourly, daily, weekly) over the last `days`, and `user`, `app`, `provider` and `route` narrow them. This is the cost and latency record for the key -- there is no separate usage endpoint via GET /v1/queries

api
apipie_ai_get_v1_stateREAD

Read the configuration APIpie has stored for this API key -- the model, memory, integrity, search and system-prompt defaults that override what a calling application asks for. With no arguments this returns the master/app state; `user` returns one end user's state and `app_name` selects a named app's state under the same key. This is the cheapest authenticated read on the surface and is what this integration probes a pasted key with via GET /v1/state

api
apipie_ai_get_vectors_fetchREAD

Read one record out of a vector collection by id, with its stored data and metadata. Both `collection_name` and `ids` are required query parameters, so this addresses a known record rather than searching -- use Query a vector collection for similarity search via GET /vectors/fetch

api
apipie_ai_post_ragtuneWRITE

Fetch a document from a `url`, extract its text, embed it and store it in a RAG-tune `collection_name`, so a later chat completion naming that collection in `rag_tune` answers from it. Supported file types are PDF, DOC, DOCX, TXT, CSV, XLS and XLSX, and `vector_provider` chooses pinecone or qdrant. APIPIE FETCHES THE URL ITSELF, so the document must be reachable from the public internet via POST /ragtune

api
apipie_ai_post_ragtune_deleteWRITE

DESTRUCTIVE AND IRREVERSIBLE. Delete a whole RAG-tune collection, or the records named by `ids` or matched by `filter`, with `delete_all` removing everything in it. There is no undo and no recycle bin: restoring a collection means re-uploading every document through Add a document to a RAG-tune collection. Any chat completion whose `rag_tune` named it stops being augmented from that moment via POST /ragtune/delete

api
apipie_ai_post_ragtune_listcollectionsWRITE

List the RAG-tune collections this API key owns. A POST that reads: APIpie's own documented call sends an empty JSON body. These are the names a chat completion's `rag_tune` parameter accepts via POST /ragtune/listcollections

api
apipie_ai_post_v1_anonWRITE

Replace the personal information in a block of text with truncated SHA-256 hashes, and get back both the anonymized text and a mapping from every original value to its replacement so the result can be re-identified later. Detection is Microsoft Presidio's, so the `type` on each mapping is a Presidio entity name (PERSON, PHONE_NUMBER, ...). NOTHING IS REDACTED AT APIPIE'S END: the text you send still travels to APIpie in full, so this de-identifies what you pass ONWARD, not what you disclose here via POST /v1/anon

api
apipie_ai_post_v1_chat_completionsWRITE

Send a prompt to any language model APIpie routes to, in the OpenAI chat-completions request shape. The body is ONE OF two schemas: the text form (`messages` of role/content strings) or the vision form, whose message content is an array of text and image_url parts. `model` takes up to five comma-separated names and returns an array of responses; `provider` and `routing` (price, perf, perf_avg) decide where a single model goes. APIpie's own extensions live here too -- `memory` with the mem_* controls, `rag_tune` naming a collection, `search_provider` with the search_* filters, `integrity` for best-of-N, and `inline_cli`. BILLED PER CALL against the connected account's credit via POST /v1/chat/completions

api
apipie_ai_post_v1_data_jsearchWRITE

Search job postings through the JSearch dataset APIpie resells, by `query` plus `country`, `language`, `date_posted`, `employment_types`, `job_requirements`, `work_from_home`, `radius` and `fields`, paged with `page` and `num_pages`. A resold third-party dataset, BILLED PER CALL, and the documented failure when the account has no credit is 402 via POST /v1/data/jsearch

api
apipie_ai_post_v1_data_real_estate_addressWRITE

Read the detail for ONE property named by its `address`, rather than searching an area. A resold third-party dataset, BILLED PER CALL, 402 without credit via POST /v1/data/real-estate/address

api
apipie_ai_post_v1_data_real_estate_coordinatesWRITE

The same property search centred on a point instead of a place name: `lat`, `long` and `diameter` are all required, and the same filters apply. Use this when the area is a radius rather than a named location. A resold third-party dataset, BILLED PER CALL, 402 without credit via POST /v1/data/real-estate/coordinates

api
apipie_ai_post_v1_data_real_estate_polygonWRITE

The same property search bounded by an arbitrary `polygon` rather than a place name or a radius -- the form to use for a drawn catchment area or an exact boundary. A resold third-party dataset, BILLED PER CALL, 402 without credit via POST /v1/data/real-estate/polygon

api
apipie_ai_post_v1_data_real_estate_searchWRITE

Search property listings for a `location` -- a city, neighbourhood or postcode -- with the full filter set: `listing_type` and `home_status`, `home_type`, price, square footage, lot size, bedroom, bathroom, HOA fee and monthly payment ranges, the for_sale_* seller and auction flags, `space_type`, `sort` and `page`. A resold third-party dataset, BILLED PER CALL, 402 without credit via POST /v1/data/real-estate/search

api
apipie_ai_post_v1_embeddingsWRITE

Turn text into an embedding vector with any of APIpie's embedding models, in the OpenAI request shape: `model` and `input` are required, `encoding_format` picks float or base64 and `dimensions` trims the vector (up to 1536). Call Fetch models with `type=embedding` for the list of models this accepts. BILLED PER CALL against the connected account's credit via POST /v1/embeddings

api
apipie_ai_post_v1_images_generationsWRITE

Generate one or more images from a `prompt` through whichever image model the account routes to, with the OpenAI image options (`model`, `n`, `size`, `quality`, `style`, `response_format`) plus APIpie's own `aspect_ratio`, `seed`, `steps`, `strength`, `loras` and `text_layout`. Passing `image` edits that image instead of generating from scratch. BILLED PER IMAGE against the connected account's credit, and image models are the most expensive route on this API via POST /v1/images/generations

api
apipie_ai_post_v1_scrapeWRITE

Fetch one `url` through APIpie's scraping providers and return its content, with `format` choosing the shape, `scrape_length` capping how much comes back and `scrape_render` asking for a rendered (JavaScript-executed) fetch. APIPIE FETCHES THE URL ITSELF from its own network, so this reaches whatever that network can reach. BILLED PER PAGE against the connected account's credit via POST /v1/scrape

api
apipie_ai_post_v1_searchWRITE

Run a web search through APIpie's search providers and get the results back as data. `query` is required; `search_provider`, `results`, `lang`, `geo`, `start_date`/`end_date`, `whitelist`/`blacklist` of root domains, `safeSearch`, `fast_mode` and `max_price` shape it, and `url_only` returns addresses without content. BILLED PER SEARCH against the connected account's credit via POST /v1/search

api
apipie_ai_post_v1_search_answerWRITE

Ask a question and get a written answer synthesised from live search results, rather than the result list itself. `query` and `search_provider` are both required and the vendor documents this route as valyu-only. `system_instructions`, `timeRange`, `geo`, `whitelist`/`blacklist` and `max_price` shape it. BILLED PER CALL -- it is a search AND a model call via POST /v1/search/answer

api
apipie_ai_post_v1_stateWRITE

MERGE new values into the configuration state for this API key: `settings` carries the model, memory, integrity and search defaults, `enable_user_states` switches the scope from per-app to per-end-user, `enable_inline_cli` turns on the `:command` tokens, and `gui_only` locks further edits to the APIpie dashboard -- INCLUDING THIS TOOL, which then stops being able to change anything. The `delete` array removes named keys from the existing settings, which is the partial-delete path; Delete the stored configuration state removes whole records. State OVERRIDES what a calling application sends, so a change here silently redirects traffic the application believes it controls via POST /v1/state

api
apipie_ai_post_vectorsWRITE

Create a vector collection -- APIpie's collection is a Pinecone index plus namespace in one -- with a `collection_name`, a `dimension` that fixes the vector size for its whole life, and a `vector_provider` of pinecone or qdrant. The dimension must match the embedding model you intend to store, and it cannot be changed afterwards via POST /vectors

api
apipie_ai_post_vectors_deleteWRITE

DESTRUCTIVE AND IRREVERSIBLE. Delete the vectors named by `ids` or matched by `filter` from `collection_name`, or -- with `delete_all` -- the entire collection and everything in it. There is no undo and no recycle bin: restoring means re-embedding and re-upserting every vector. `delete_all` is the wide form and is the one to be careful with via POST /vectors/delete

api
apipie_ai_post_vectors_listWRITE

Page through the vector ids in one `collection_name`, optionally only those under a `prefix`, with `limit` per page and `pagination_token` carrying the next page. Ids only -- read a record's content with Fetch a vector record via POST /vectors/list

api
apipie_ai_post_vectors_listcollectionsWRITE

List the vector collections this API key owns. A POST that reads: APIpie's own documented call sends an empty JSON body. A collection here is a namespace, not a Pinecone enterprise collection via POST /vectors/listcollections

api
apipie_ai_post_vectors_queryWRITE

Similarity search: hand a query `vector` to a `collection_name` and get the `top_k` nearest records back, narrowed by `filter` or `metatag`, with `include_values` and `include_metadata` deciding how much of each hit comes back. This is the read that powers a hand-rolled RAG pipeline; RAG tuning is the managed alternative via POST /vectors/query

api
apipie_ai_put_vectors_upsertWRITE

Insert or REPLACE one vector in a collection, by `vector_id`: its `embedding` array, the clear-text `data` kept alongside it and an optional `metatag`. Upserting an id that already exists overwrites the stored vector and its data rather than adding a second one, and the embedding's length must match the dimension the collection was created with via PUT /vectors/upsert

api

Put APIpie behind one governed endpoint.

Same permissions, same audit trail, whatever else you connect next.