REST API

A fully functional REST API is automatically generated from your Collection configs.

The REST API is a fully functional HTTP client that allows you to interact with your Documents in a RESTful manner. It supports all CRUD operations and is equipped with automatic pagination, depth, and sorting. All FrogBot API routes are mounted and prefixed to your config’s routes.api URL segment (default: /api). For example, if you have a Collection called pages, you can fetch its documents directly from the browser or any HTTP client:

fetch('https://localhost:3000/api/pages')
  .then((res) => res.json())
  .then((data) => console.log(data))

To enhance DX, you can use FrogBot SDK to query your REST API. REST query parameters:

depth - automatically populates relationships and uploads
locale - retrieves document(s) in a specific locale
fallback-locale - specifies a fallback locale if no locale value exists
select - specifies which fields to include in the result
populate - specifies which fields to include in the result from populated documents
limit - limits the number of documents returned
page - specifies which page to get documents from when used with a limit
sort - specifies the field(s) to use to sort the returned documents by
where - specifies advanced filters to use to query documents
joins - specifies the custom request for each join field by name of the field. joins[field]=false leaves that field out; joins=false has no effect

Collections

Each collection is mounted using its slug value. For example, if a collection’s slug is users, all corresponding routes will be mounted on /api/users. Note: Collection slugs must be formatted in kebab-case All CRUD operations are exposed as follows:

Operation	Method	Path	Description
Find	`GET`	`/api/{collection-slug}`	Find paginated documents
Find By ID	`GET`	`/api/{collection-slug}/{id}`	Find a specific document by ID
Count	`GET`	`/api/{collection-slug}/count`	Count the documents
Create	`POST`	`/api/{collection-slug}`	Create a new document
Update	`PATCH`	`/api/{collection-slug}`	Update all documents matching the where query
Update By ID	`PATCH`	`/api/{collection-slug}/{id}`	Update a document by ID
Delete	`DELETE`	`/api/{collection-slug}`	Delete all documents matching the where query
Delete by ID	`DELETE`	`/api/{collection-slug}/{id}`	Delete an existing document by ID

Auth Operations

Auth enabled collections are also given the following endpoints:

Operation	Method	Path	Description
Login	`POST`	`/api/{user-collection}/login`	Logs in a user with email / password
Logout	`POST`	`/api/{user-collection}/logout`	Logs out a user
Unlock	`POST`	`/api/{user-collection}/unlock`	Unlock a user account
Refresh	`POST`	`/api/{user-collection}/refresh-token`	Refreshes a token that has not yet expired
Verify User	`POST`	`/api/{user-collection}/verify/{token}`	User verification
Current User	`GET`	`/api/{user-collection}/me`	Returns the currently logged in user
Forgot Password	`POST`	`/api/{user-collection}/forgot-password`	Password reset workflow entry point
Reset Password	`POST`	`/api/{user-collection}/reset-password`	Reset user password

Preferences

In addition to the dynamically generated endpoints above, FrogBot has REST endpoints to manage admin user preferences for data specific to the authenticated user.

Operation	Method	Path	Description
Get Preference	`GET`	`/api/frogbot-preferences/{key}`	Get a preference by key
Create Preference	`POST`	`/api/frogbot-preferences/{key}`	Create or update a preference by key
Delete Preference	`DELETE`	`/api/frogbot-preferences/{key}`	Delete a preference by key

Custom Endpoints

Additional REST API endpoints can be added to your application by providing an array of endpoints in various places within a FrogBot Config. Custom endpoints are useful for adding additional middleware on existing routes or for building custom functionality into FrogBot apps and plugins. Endpoints can be added at the top of the FrogBot Config or to collections and accessed through the API and slugs you have configured.

Custom endpoints are not authenticated by default. You are responsible for securing your own endpoints.

Each endpoint object needs to have:

Property	Type	Default	Description
`path`	`string`	Required	The route after the collection slug, or after `routes.api` for root endpoints. Supports path parameters such as `/:id/tracking`, read from `req.routeParams`.
`method`	`'get' \| 'head' \| 'post' \| 'put' \| 'patch' \| 'delete' \| 'connect' \| 'options'`	Required	The lowercase HTTP verb to use.
`handler`	`(req: FrogBotRequest) => Response \| Promise<Response>`	Required	A function that accepts req - `FrogBotRequest` object which contains Web Request properties, currently authenticated `user` and the Local API instance `frogbot`.
`custom`	`Record<string, any>`	—	Extension point for adding custom data (e.g. for plugins).

Example:

import type { CollectionConfig } from 'frogbot'

// a collection of 'orders' with an additional route for tracking details, reachable at /api/orders/:id/tracking
export const Orders: CollectionConfig = {
  slug: 'orders',
  fields: [
    /* ... */
  ],
  endpoints: [
    {
      path: '/:id/tracking',
      method: 'get',
      handler: async (req) => {
        const tracking = await getTrackingInfo(req.routeParams.id)

        if (!tracking) {
          return Response.json({ error: 'not found' }, { status: 404 })
        }

        return Response.json({
          message: `Hello ${req.routeParams.name as string} @ ${req.routeParams.group as string}`,
        })
      },
    },
    {
      path: '/:id/tracking',
      method: 'post',
      handler: async (req) => {
        // `data` is not automatically appended to the request
        // if you would like to read the body of the request
        // you can use `data = await req.json()`
        const data = await req.json()
        await req.frogbot.update({
          collection: 'tracking',
          overrideAccess: false,
          req,
          data: {
            // data to update the document with
          },
        })
        return Response.json({
          message: 'successfully updated tracking info',
        })
      },
    },
    {
      path: '/:id/forbidden',
      method: 'post',
      handler: async (req) => {
        // this is an example of an authenticated endpoint
        if (!req.user) {
          return Response.json({ error: 'forbidden' }, { status: 403 })
        }

        // do something

        return Response.json({
          message: 'successfully updated tracking info',
        })
      },
    },
  ],
}

req will have the frogbot object and can be used inside your endpoint handlers for making calls like req.frogbot.find() that will make use of Access Control and Hooks.

Helpful tips

req.data Data is not automatically appended to the request. You can read the body data by calling await req.json(). Or you could use our helper function that mutates the request and appends data and file if found.

import { addDataAndFileToRequest } from 'frogbot'

// custom endpoint example
{
  path: '/:id/tracking',
  method: 'post',
  handler: async (req) => {
    await addDataAndFileToRequest(req)
    await req.frogbot.update({
      collection: 'tracking',
      overrideAccess: false,
      req,
      data: {
        // data to update the document with
      }
    })
    return Response.json({
      message: 'successfully updated tracking info'
    })
  }
}

req.locale & req.fallbackLocale The locale and the fallback locale are not automatically appended to custom endpoint requests. If you would like to add them you can use this helper function.

import { addLocalesToRequestFromData } from 'frogbot'

// custom endpoint example
{
  path: '/:id/tracking',
  method: 'post',
  handler: async (req) => {
    await addLocalesToRequestFromData(req)
    // you now can access req.locale & req.fallbackLocale
    return Response.json({ message: 'success' })
  }
}

headersWithCors By default, custom endpoints don’t handle CORS headers in responses. The headersWithCors function checks the FrogBot config and sets the appropriate CORS headers in the response accordingly.

import { headersWithCors } from 'frogbot'

// custom endpoint example
{
  path: '/:id/tracking',
  method: 'post',
  handler: async (req) => {
    return Response.json(
      { message: 'success' },
      {
        headers: headersWithCors({
          headers: new Headers(),
          req,
        })
      },
    )
  }
}

Method Override for GET Requests

FrogBot supports a method override feature that allows you to send GET requests using the HTTP POST method. This can be particularly useful in scenarios when the query string in a regular GET request is too long.

How to Use

To use this feature, include the X-HTTP-Method-Override header set to GET in your POST request. The parameters should be sent in the body of the request with the Content-Type set to application/x-www-form-urlencoded. For cross-origin requests from a browser, add the header to the allowed CORS headers: cors: { origins: ['https://app.example.com'], headers: ['X-HTTP-Method-Override'] }.

Example

Here is an example of how to use the method override to perform a GET request:

Using Method Override (POST)

const res = await fetch(`${api}/${collectionSlug}`, {
  method: 'POST',
  credentials: 'include',
  headers: {
    'Accept-Language': i18n.language,
    'Content-Type': 'application/x-www-form-urlencoded',
    'X-HTTP-Method-Override': 'GET',
  },
  body: qs.stringify({
    depth: 1,
    locale: 'en',
  }),
})

Equivalent Regular GET Request

const res = await fetch(`${api}/${collectionSlug}?depth=1&locale=en`, {
  method: 'GET',
  credentials: 'include',
  headers: {
    'Accept-Language': i18n.language,
  },
})

Passing as JSON

When using X-HTTP-Method-Override, it expects the body to be a query string. If you want to pass JSON instead, you can set the Content-Type to application/json and include the JSON body in the request.

Example

const res = await fetch(`${api}/${collectionSlug}/${id}`, {
  // Only the findByID endpoint supports HTTP method overrides with JSON data
  method: 'POST',
  credentials: 'include',
  headers: {
    'Accept-Language': i18n.language,
    'Content-Type': 'application/json',
    'X-HTTP-Method-Override': 'GET',
  },
  body: JSON.stringify({
    depth: 1,
    locale: 'en',
  }),
})

This can be more efficient for large JSON payloads, as you avoid converting data to and from query strings. However, only certain endpoints support this. Supported endpoints will read the parsed body under a data property, instead of reading from query parameters as with standard GET requests.

FrogBot REST API SDK

@frogbotai/sdk is a typed client for the FrogBot REST API. It works in any frontend: a Next.js app, a Vite or plain browser app, a mobile app, or a script.

The SDK package is currently in beta and may be subject to change in minor versions updates prior to being stable.

Install and types

Install the SDK, and install frogbot as a dev dependency for its types:

pnpm add @frogbotai/sdk
pnpm add -D frogbot

frogbot is only used for types and is never bundled into your frontend. Without it, the SDK still runs, but its results are untyped (any), and TypeScript reports that the generated types file can’t find the frogbot module. Copy your app’s generated types file, frogbot-types.ts, into the frontend. Once it’s part of the project, every SDK call is typed from it: collection slugs, where fields, select, and the documents you get back. A misspelled collection slug is a compile error. Before types are generated, the SDK still works, and documents are typed as plain objects. Types need skipLibCheck: true in your tsconfig.json. FrogBot’s starter already sets it. Without it, TypeScript reports errors from third-party packages that frogbot’s types reference.

import { createFrogBotSDK } from '@frogbotai/sdk'

const sdk = createFrogBotSDK({
  baseURL: 'https://example.com/api',
})

createFrogBotSDK() accepts:

Option	Type	Default	Description
`baseURL`	`string`	Required	URL of your app’s REST API, including `routes.api`, such as `https://example.com/api`. A trailing slash is removed.
`fetch`	`typeof fetch`	`globalThis.fetch`	Function used to send every request. Wrap `fetch` to add options such as `credentials`.
`headers`	`HeadersInit`	—	Headers sent with every request. Headers passed to a method override them.

To pick the types explicitly, for example when a frontend talks to more than one FrogBot app, pass the generated Config:

import { createFrogBotSDK } from '@frogbotai/sdk'

import type { Config } from './frogbot-types'

const sdk = createFrogBotSDK<Config>({
  baseURL: 'https://example.com/api',
})

In a monorepo, share the file through a types package instead of copying it. For example, an @acme/types package whose index.ts re-exports the generated file:

export * from './frogbot-types'

Add @acme/types and frogbot as dev dependencies of each frontend, and import Config from @acme/types.

Operations

These examples use a posts collection with title and slug fields and drafts enabled. Find documents with where, select, sort, and pagination. The query string is built for you:

const posts = await sdk.find({
  collection: 'posts',
  where: { title: { contains: 'frog' } },
  select: { title: true, slug: true },
  sort: '-createdAt',
  limit: 10,
  page: 1,
})

posts.docs[0]?.title

Find a document by ID. Pass draft: true for the latest draft, which needs an authenticated request. With disableErrors: true, a missing document returns null instead of throwing:

const post = await sdk.findByID(
  { collection: 'posts', id, draft: true, disableErrors: true },
  { headers: { Authorization: `JWT ${token}` } },
)

if (post) console.log(post.title)

Count, create, update, and delete:

const { totalDocs } = await sdk.count({
  collection: 'posts',
  where: { slug: { exists: true } },
})

const post = await sdk.create({ collection: 'posts', data: { title: 'New post' } })

await sdk.update({ collection: 'posts', id: post.id, data: { title: 'Updated post' } })

await sdk.update({
  collection: 'posts',
  where: { title: { equals: 'Updated post' } },
  data: { slug: 'updated-post' },
})

await sdk.delete({ collection: 'posts', id: post.id })

await sdk.delete({ collection: 'posts', where: { slug: { equals: 'updated-post' } } })

Update and delete with id return the document. With where, they return { docs, errors }. Read and restore versions:

const versions = await sdk.findVersions({
  collection: 'posts',
  where: { parent: { equals: post.id } },
})

const version = await sdk.findVersionByID({ collection: 'posts', id: versions.docs[0].id })

await sdk.restoreVersion({ collection: 'posts', id: version.id })

Run a search against one of the collection’s search indexes. Hits are typed documents with their score:

const { mode, hits } = await sdk.search({
  collection: 'posts',
  index: 'content',
  query: { text: 'frogs' },
  where: { slug: { exists: true } },
  limit: 5,
})

hits[0]?.doc.title

Search several collections with one query using searchMany. This example also uses a pages collection with a content index. Results come back in the order you list the collections, one ranked list each, with limit applied per collection:

const { results } = await sdk.searchMany({
  collections: [
    { collection: 'posts', index: 'content', where: { slug: { exists: true } } },
    { collection: 'pages', index: 'content', select: { title: true } },
  ],
  query: { text: 'frogs' },
  limit: 5,
})

const [posts, pages] = results

posts.hits[0]?.doc.title

Each entry’s where suggests that collection’s fields, and each list’s hits are typed as that collection’s documents. When you loop over results, checking result.collection narrows them. FrogBot doesn’t order hits from different collections against each other; see Search several collections. Every method takes standard RequestInit options, such as headers or credentials, as its last argument. Non-success responses throw FrogBotSDKError, with the HTTP status and the server’s errors:

import { FrogBotSDKError } from '@frogbotai/sdk'

try {
  await sdk.create({ collection: 'posts', data: { title: '' } })
} catch (error) {
  if (error instanceof FrogBotSDKError) console.log(error.status, error.errors)
}

Authentication

The SDK does not store login tokens. Log in, then send the token on later requests with a JWT header:

const { token } = await sdk.login({
  collection: 'users',
  data: { email: 'dev@example.com', password: 'your-password' },
})

const authenticatedSDK = createFrogBotSDK({
  baseURL: 'https://example.com/api',
  headers: { Authorization: `JWT ${token}` },
})

const { user } = await authenticatedSDK.me({ collection: 'users' })

Request-specific headers in the second argument are merged with the configured headers. refreshToken, forgotPassword, resetPassword, and verifyEmail follow the same pattern; see authentication operations. Send an API key as a Bearer token:

const sdk = createFrogBotSDK({
  baseURL: 'https://example.com/api',
  headers: { Authorization: `Bearer ${apiKey}` },
})

In the browser, use session cookies instead by including credentials on every request:

const sdk = createFrogBotSDK({
  baseURL: 'https://example.com/api',
  fetch: (url, init) => fetch(url, { credentials: 'include', ...init }),
})

await sdk.login({
  collection: 'users',
  data: { email: 'dev@example.com', password: 'your-password' },
})

Cross-origin cookie requests require the server’s CORS and cookie configuration.

Uploads

Create a document in an upload collection with a File, or a URL to fetch the file from, and its data:

const file = new File(['Hello'], 'hello.txt', { type: 'text/plain' })

const media = await sdk.create({ collection: 'media', file, data: { alt: 'File description' } })

This example requires an upload-enabled media collection with an alt field. For an upload that needs no data, upload(collection, file) is a shorthand. This example targets your app’s files collection:

const uploaded = await sdk.upload('files', file)

upload() returns the stored document, typed as FrogBotUpload: its id, filename, and mimeType, plus every other field the collection returns, such as url, filesize, or a chat asset’s text. Those other fields are typed unknown, so check their type before use. A rejected upload throws FrogBotSDKError.

Custom endpoints

Use request(path, init) for custom endpoints. It returns a Web Response and throws FrogBotSDKError for non-success responses. The json option serializes the body and sets Content-Type:

const response = await sdk.request('/send-data', {
  method: 'POST',
  json: { id: 1 },
})

const result = await response.json()

Options reference

Every method’s last argument, init, takes standard RequestInit options that are merged into the request. Its headers override the configured headers. find(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	`false`	Query the latest drafts instead of published documents.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`joins`	`JoinQuery`	—	Pagination, sort, and filters per join field, such as `{ relatedPosts: { limit: 5 } }`. Set a join field to `false` to leave it out of the result.
`limit`	`number`	`10`	The maximum number of documents to return.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`page`	`number`	`1`	The page of results to return.
`pagination`	`boolean`	`true`	Set to `false` to skip the document count.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`sort`	`string \| string[]`	—	Sort by one or more fields. Prefix a field with `-` to sort descending.
`trash`	`boolean`	`false`	Include trashed documents. Has no effect unless the collection has `trash` enabled.
`where`	`Where`	—	A filter query.

findByID(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`id`	`string \| number`	Required	The ID of the document to find.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`disableErrors`	`boolean`	`false`	Return `null` instead of throwing when the document isn’t found or the request fails.
`draft`	`boolean`	`false`	Return the latest draft instead of the published document.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`joins`	`JoinQuery`	—	Pagination, sort, and filters per join field, such as `{ relatedPosts: { limit: 5 } }`. Set a join field to `false` to leave it out of the result.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`trash`	`boolean`	`false`	Return the document even if it’s trashed. Has no effect unless the collection has `trash` enabled.

count(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`trash`	`boolean`	`false`	Include trashed documents in the count. Has no effect unless the collection has `trash` enabled.
`where`	`Where`	—	A filter query.

create(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`data`	`object`	Required	The data for the document to create.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	`false`	Create the document as a draft.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`file`	`Blob \| string`	—	Upload collections only. The file, or a URL to fetch it from.
`locale`	`'all' \| TypedLocale`	—	The locale of the data and the returned document.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.

update(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`data`	`object`	Required	The fields to update.
`id`	`string \| number`	Required without `where`	The ID of the document to update. Returns the document.
`where`	`Where`	Required without `id`	Selects the documents to update. Returns `{ docs, errors }`.
`limit`	`number`	—	With `where`, the maximum number of documents to update.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	`false`	Save the update as a draft.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`file`	`Blob \| string`	—	Upload collections only. The new file, or a URL to fetch it from.
`locale`	`TypedLocale`	—	The locale of the data and the returned documents.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`trash`	`boolean`	`false`	Allow the update to target trashed documents. Has no effect unless the collection has `trash` enabled.
`autosave`	`boolean`	`false`	With `id` and `draft: true`, save the update as an autosave of the current draft. Needs `versions.drafts.autosave`.
`publishAllLocales`	`boolean`	—	Publishes every locale. Without it, a publish with `_status: 'published'` publishes only `locale`. Needs status localization.
`unpublishAllLocales`	`boolean`	—	Unpublishes every locale. Needs status localization.

delete(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`id`	`string \| number`	Required without `where`	The ID of the document to delete. Returns the document.
`where`	`Where`	Required without `id`	Selects the documents to delete. Returns `{ docs, errors }`.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	—	Sent as the `draft` query parameter.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`locale`	`TypedLocale`	—	The locale of the returned documents.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`trash`	`boolean`	`false`	Allow the delete to target trashed documents. Has no effect unless the collection has `trash` enabled.

findVersions(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	—	Include draft versions.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`limit`	`number`	`10`	The maximum number of versions to return.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`page`	`number`	`1`	The page of results to return.
`pagination`	`boolean`	`true`	Set to `false` to skip the version count.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`sort`	`string \| string[]`	—	Sort by one or more fields, such as `'-version.createdAt'`.
`trash`	`boolean`	`false`	Include versions of trashed documents. Has no effect unless the collection has `trash` enabled.
`where`	`Where`	—	A filter query, for example `{ parent: { equals: id } }`.

findVersionByID(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`id`	`string \| number`	Required	The ID of the version to find.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`disableErrors`	`boolean`	`false`	Return `null` instead of throwing when the version isn’t found or the request fails.
`draft`	`boolean`	—	Include draft versions.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.
`select`	`SelectType`	—	Which fields to include in the result.
`trash`	`boolean`	`false`	Return the version even if its document is trashed. Has no effect unless the collection has `trash` enabled.

restoreVersion(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`id`	`string \| number`	Required	The ID of the version to restore.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	—	Restore the version as a draft.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.
`locale`	`'all' \| TypedLocale`	—	The locale of the returned documents.
`populate`	`PopulateType`	—	Which fields to include from populated documents, per collection.

search(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to search.
`index`	`string`	Required	The name of the collection’s search index to query.
`query`	`SearchQuery`	Required	The text, vector, or both to search for.
`where`	`Where`	—	A filter query applied to the hits.
`limit`	`number`	Server default	The maximum number of hits to return.
`candidates`	`number`	Server default	How many candidates each ranking method considers before the final hits are chosen.
`select`	`SelectType`	—	Which fields to include in each hit’s document.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.
`draft`	`boolean`	`false`	Search the latest drafts instead of published documents.
`locale`	`string`	—	The locale of the returned documents.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.

searchMany(options, init?)

Option	Type	Default	Description
`collections`	`SearchManyCollection[]`	Required	The collections to search, each with the options below. Results follow this order. Must not be empty, and a collection can appear only once.
`query`	`SearchQuery`	Required	The text, vector, or both to search for in every collection.
`limit`	`number`	Server default	The maximum number of hits per collection.
`draft`	`boolean`	`false`	Search the latest drafts instead of published documents.
`locale`	`string`	—	The locale of the returned documents.
`fallbackLocale`	`false \| TypedLocale`	—	The locale to fall back to when a localized field has no value. `false` turns fallback off, so untranslated fields come back empty.

Each entry in collections accepts:

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to search.
`index`	`string`	Required	The name of this collection’s search index to query.
`where`	`Where`	—	A filter query applied to this collection’s hits.
`select`	`SelectType`	—	Which fields to include in each hit’s document.
`candidates`	`number`	Server default	How many candidates each ranking method considers before the final hits are chosen.
`depth`	`number`	Server default	How many levels of relationship and upload fields to populate.

The server always enforces the caller’s access. A collection the caller can’t read fails the whole call with a 403 FrogBotSDKError. login(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`data`	`{ email: string; password: string }`	Required	The user’s credentials.

me(options, init?) and refreshToken(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.

forgotPassword(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`data.email`	`string`	Required	The email address to send the reset link to.

Skipping the email and setting the token’s expiration are only available in the Local API, so a public caller can’t change how password resets work. resetPassword(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`data`	`{ password: string; token: string }`	Required	The new password and the token from `forgotPassword`.

verifyEmail(options, init?)

Option	Type	Default	Description
`collection`	`string`	Required	The collection slug to operate against.
`token`	`string`	Required	The verification token.

request(path, init?)

Option	Type	Default	Description
`path`	`string`	Required	Path below `baseURL`. A leading `/` is added when missing.
`init`	`RequestInit & { json?: unknown }`	`{}`	Standard fetch options. `json` is serialized as the body and sets `Content-Type: application/json`. Headers are merged over the configured `headers`.

Start here

Basics

Managing Data

Features

Ecosystem

Deployment

Collections

Auth Operations

Preferences

Custom Endpoints

Helpful tips

Method Override for GET Requests

How to Use

Example

Using Method Override (POST)

Equivalent Regular GET Request

Passing as JSON

Example

FrogBot REST API SDK

Install and types

Operations

Authentication

Uploads

Custom endpoints

Options reference

​Collections

​Auth Operations

​Preferences

​Custom Endpoints

​Helpful tips

​Method Override for GET Requests

​How to Use

​Example

​Using Method Override (POST)

​Equivalent Regular GET Request

​Passing as JSON

​Example

​FrogBot REST API SDK

​Install and types

​Operations

​Authentication

​Uploads

​Custom endpoints

​Options reference

Collections

Auth Operations

Preferences

Custom Endpoints

Helpful tips

Method Override for GET Requests

How to Use

Example

Using Method Override (POST)

Equivalent Regular GET Request

Passing as JSON

Example

FrogBot REST API SDK

Install and types

Operations

Authentication

Uploads

Custom endpoints

Options reference